Fórum témák
- • Theremin
- • Börze
- • Elfogadnám, ha ingyen elvihető
- • Felajánlás, azaz ingyen elvihető
- • Alternativ HE találkozó(k)
- • LCD TV probléma
- • Napelem alkalmazása a lakás energia ellátásában
- • Általános antennás kérdések, válaszok
- • Inverter javítás
- • Erősítő mindig és mindig
- • Számítógép hiba, de mi a probléma?
- • Crystal radio - detektoros rádió
- • V-FET és SIT erősítő kapcsolások
- • Rádióamatőrök topikja
- • XBOX kiegészítők, javítások átalakítások
- • Hangsugárzó építés, javítás - miértek, hogyanok
- • Elektromos fűnyíró probléma
- • Digitális mérleg
- • Parkside akkuk javìtása
- • Briggs töltés
- • Erősítő építése elejétől a végéig
- • Vásárlás, hol kapható?
- • 3D nyomtatás
- • Laptop javítás, tuning
- • Kapcsolóüzemű táp 230V-ról
- • Érdekességek
- • Transzformátor készítés, méretezés
- • Milyen zsebrádiót vegyek,amivel a gyenge rádióadókat is tudom fogni?
- • Tápegység
- • Elektromos kerékpár, robogó házilag
- • Relé kérdés
- • PIC - Miértek, hogyanok haladóknak
- • Erősítőhöz való hangsugárzó védelem (koppanásgátló)
- • Autórádió (fejegység) problémák, kérdések, válaszok
- • Arduino
- • Oszcilloszkóp, avagy hogyan kell használni?
- • Analóg oszcilloszkóp javítása
- • Akkumulátor töltő
- • Dansk 3f-T3535, és minden, ami vele kapcsolatos
- • Klíma szervizelés, javítás
- • PC-ről vezérlés
- • Labortápegység készítése
- • Videoton EA 6383 s (tuning)
- • Rossz pénztárgép
- • Androidos okos telefonok
- • METEX műszer
- • Villámdetektor
- • Kaputelefon
- • Elektromos távirányítós kapunyitó
- • Forrasztópáka fűtés probléma
- • Mosógép vezérlők és általános problémáik
- • LC mérő
- • NYÁK terv ellenőrzése
- • Függvénygenerátor építése
- • Multiméter - miért, milyet?
» Több friss téma
|
A klónok CH340 Soros-USB illesztőjének drivere ( Letöltés)
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
/* I2C_EEPROMtest.ino
* Use the I2C bus with EEPROM 24LC64
* Sketch: eeprom.ino
*
* Author: hkhijhe
* Date: 01/10/2010
*
*
*/
/////////////////////////////////////////////////////////////////////////////////////////
// General include
#include "Wire.h"
void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
int rdata = data;
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.write(rdata);
Wire.endTransmission();
}
// WARNING: address is a page address, 6-bit end will wrap around
// also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddresspage >> 8)); // MSB
Wire.write((int)(eeaddresspage & 0xFF)); // LSB
byte c;
for ( c = 0; c < length; c++)
Wire.write(data[c]);
Wire.endTransmission();
}
byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
byte rdata = 0xFF;
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.endTransmission();
Wire.requestFrom(deviceaddress,1);
if (Wire.available()) rdata = Wire.read();
return rdata;
}
// maybe let's not read more than 30 or 32 bytes at a time!
void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.endTransmission();
Wire.requestFrom(deviceaddress,length);
int c = 0;
for ( c = 0; c < length; c++ )
if (Wire.available()) buffer[c] = Wire.read();
}
void setup()
{
char somedata[] = "this is data from the eeprom"; // data to write
Wire.begin(); // initialise the connection
Serial.begin(9600);
i2c_eeprom_write_page(0x50, 0, (byte *)somedata, sizeof(somedata)); // write to EEPROM
delay(100); //add a small delay
Serial.println("Memory written");
}
void loop()
{
int addr=0; //first address
byte b = i2c_eeprom_read_byte(0x50, 0); // access the first address from the memory
while (b!=0)
{
Serial.print((char)b); //print content to serial port
addr++; //increase address
b = i2c_eeprom_read_byte(0x50, addr); //access an address from the memory
}
Serial.println(" ");
delay(2000);
}
/* Wire.h
TwoWire.h - TWI/I2C library for Arduino & Wiring
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
*/
#ifndef TwoWire_h
#define TwoWire_h
#include <inttypes.h>
#include "Stream.h"
#define BUFFER_LENGTH 32
// ESP-12
//#define SDA 4
//#define SCL 5
// ESP-01
#define SDA 0
#define SCL 2
class TwoWire : public Stream
{
private:
static uint8_t rxBuffer[];
static uint8_t rxBufferIndex;
static uint8_t rxBufferLength;
static uint8_t txAddress;
static uint8_t txBuffer[];
static uint8_t txBufferIndex;
static uint8_t txBufferLength;
static uint8_t transmitting;
static void (*user_onRequest)(void);
static void (*user_onReceive)(int);
static void onRequestService(void);
static void onReceiveService(uint8_t*, int);
public:
TwoWire();
void begin(int sda, int scl);
void pins(int sda, int scl) __attribute__((deprecated)); // use begin(sda, scl) in new code
void begin();
void begin(uint8_t);
void begin(int);
void setClock(uint32_t);
void beginTransmission(uint8_t);
void beginTransmission(int);
uint8_t endTransmission(void);
uint8_t endTransmission(uint8_t);
size_t requestFrom(uint8_t address, size_t size, bool sendStop);
uint8_t requestFrom(uint8_t, uint8_t);
uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
uint8_t requestFrom(int, int);
uint8_t requestFrom(int, int, int);
virtual size_t write(uint8_t);
virtual size_t write(const uint8_t *, size_t);
virtual int available(void);
virtual int read(void);
virtual int peek(void);
virtual void flush(void);
void onReceive( void (*)(int) );
void onRequest( void (*)(void) );
inline size_t write(unsigned long n) { return write((uint8_t)n); }
inline size_t write(long n) { return write((uint8_t)n); }
inline size_t write(unsigned int n) { return write((uint8_t)n); }
inline size_t write(int n) { return write((uint8_t)n); }
using Print::write;
};
extern TwoWire Wire;
#endif
/* Wire.cpp
TwoWire.cpp - TWI/I2C library for Arduino & Wiring
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
*/
extern "C" {
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
}
#include "twi.h"
#include "Wire.h"
// Initialize Class Variables //////////////////////////////////////////////////
uint8_t TwoWire::rxBuffer[BUFFER_LENGTH];
uint8_t TwoWire::rxBufferIndex = 0;
uint8_t TwoWire::rxBufferLength = 0;
uint8_t TwoWire::txAddress = 0;
uint8_t TwoWire::txBuffer[BUFFER_LENGTH];
uint8_t TwoWire::txBufferIndex = 0;
uint8_t TwoWire::txBufferLength = 0;
uint8_t TwoWire::transmitting = 0;
void (*TwoWire::user_onRequest)(void);
void (*TwoWire::user_onReceive)(int);
static int default_sda_pin = SDA;
static int default_scl_pin = SCL;
// Constructors ////////////////////////////////////////////////////////////////
TwoWire::TwoWire(){}
// Public Methods //////////////////////////////////////////////////////////////
void TwoWire::begin(int sda, int scl){
default_sda_pin = sda;
default_scl_pin = scl;
twi_init(sda, scl);
flush();
}
void TwoWire::pins(int sda, int scl){
default_sda_pin = sda;
default_scl_pin = scl;
}
void TwoWire::begin(void){
begin(default_sda_pin, default_scl_pin);
}
void TwoWire::begin(uint8_t address){
// twi_setAddress(address);
// twi_attachSlaveTxEvent(onRequestService);
// twi_attachSlaveRxEvent(onReceiveService);
begin();
}
void TwoWire::begin(int address){
begin((uint8_t)address);
}
void TwoWire::setClock(uint32_t frequency){
twi_setClock(frequency);
}
size_t TwoWire::requestFrom(uint8_t address, size_t size, bool sendStop){
if(size > BUFFER_LENGTH){
size = BUFFER_LENGTH;
}
size_t read = (twi_readFrom(address, rxBuffer, size, sendStop) == 0)?size:0;
rxBufferIndex = 0;
rxBufferLength = read;
return read;
}
uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop){
return requestFrom(address, static_cast<size_t>(quantity), static_cast<bool>(sendStop));
}
uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity){
return requestFrom(address, static_cast<size_t>(quantity), true);
}
uint8_t TwoWire::requestFrom(int address, int quantity){
return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), true);
}
uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop){
return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), static_cast<bool>(sendStop));
}
void TwoWire::beginTransmission(uint8_t address){
transmitting = 1;
txAddress = address;
txBufferIndex = 0;
txBufferLength = 0;
}
void TwoWire::beginTransmission(int address){
beginTransmission((uint8_t)address);
}
uint8_t TwoWire::endTransmission(uint8_t sendStop){
int8_t ret = twi_writeTo(txAddress, txBuffer, txBufferLength, sendStop);
txBufferIndex = 0;
txBufferLength = 0;
transmitting = 0;
return ret;
}
uint8_t TwoWire::endTransmission(void){
return endTransmission(true);
}
size_t TwoWire::write(uint8_t data){
if(transmitting){
if(txBufferLength >= BUFFER_LENGTH){
setWriteError();
return 0;
}
txBuffer[txBufferIndex] = data;
++txBufferIndex;
txBufferLength = txBufferIndex;
} else {
// i2c_slave_transmit(&data, 1);
}
return 1;
}
size_t TwoWire::write(const uint8_t *data, size_t quantity){
if(transmitting){
for(size_t i = 0; i < quantity; ++i){
if(!write(data[i])) return i;
}
}else{
// i2c_slave_transmit(data, quantity);
}
return quantity;
}
int TwoWire::available(void){
int result = rxBufferLength - rxBufferIndex;
if (!result) {
// yielding here will not make more data "available",
// but it will prevent the system from going into WDT reset
optimistic_yield(1000);
}
return result;
}
int TwoWire::read(void){
int value = -1;
if(rxBufferIndex < rxBufferLength){
value = rxBuffer[rxBufferIndex];
++rxBufferIndex;
}
return value;
}
int TwoWire::peek(void){
int value = -1;
if(rxBufferIndex < rxBufferLength){
value = rxBuffer[rxBufferIndex];
}
return value;
}
void TwoWire::flush(void){
rxBufferIndex = 0;
rxBufferLength = 0;
txBufferIndex = 0;
txBufferLength = 0;
}
void TwoWire::onReceiveService(uint8_t* inBytes, int numBytes)
{
// don't bother if user hasn't registered a callback
// if(!user_onReceive){
// return;
// }
// // don't bother if rx buffer is in use by a master requestFrom() op
// // i know this drops data, but it allows for slight stupidity
// // meaning, they may not have read all the master requestFrom() data yet
// if(rxBufferIndex < rxBufferLength){
// return;
// }
// // copy twi rx buffer into local read buffer
// // this enables new reads to happen in parallel
// for(uint8_t i = 0; i < numBytes; ++i){
// rxBuffer[i] = inBytes[i];
// }
// // set rx iterator vars
// rxBufferIndex = 0;
// rxBufferLength = numBytes;
// // alert user program
// user_onReceive(numBytes);
}
void TwoWire::onRequestService(void){
// // don't bother if user hasn't registered a callback
// if(!user_onRequest){
// return;
// }
// // reset tx buffer iterator vars
// // !!! this will kill any pending pre-master sendTo() activity
// txBufferIndex = 0;
// txBufferLength = 0;
// // alert user program
// user_onRequest();
}
void TwoWire::onReceive( void (*function)(int) ){
//user_onReceive = function;
}
void TwoWire::onRequest( void (*function)(void) ){
//user_onRequest = function;
}
// Preinstantiate Objects //////////////////////////////////////////////////////
TwoWire Wire = TwoWire();
A hozzászólás módosítva: Aug 2, 2017
Köszi, természetesen kipróbálom és jelzek!
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
Telepítetted a jre 1.8-at?
JRE
char* text;
String text = ("Sorszam: " + sorszamstring + ", Suly: " + sulystring + ", Homerseklet: " + hofokstring + ", Akkumlator: " + akkustring);
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
Szia!
GSM.begin(4800);
vagy egyéb számmal, pl 9600? megvan előtte?
példa:
void setup(){
GSM.begin(4800);
text="Testing Sms"; //text for the message.
number="2926451386"; //change to a valid number.
error=GSM.sendSms(number,text);
// OR
//Sim800L.sendSms("+540111111111","the text go here")
}
Ez a linkelt példákból van.
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.
A példában:
char* text;
char* number;
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.
illetve ez pontosan micsoda?
char* text;
String text = ("Sorszam: " + sorszamstring + ", Suly: " + sulystring + ", Homerseklet: " + hofokstring + ", Akkumlator: " + akkustring);
Most string, vagy char? A hozzászólás módosítva: 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.
char text[150];
String tmp = ("Sorszam: " + sorszamstring + ", Suly: " + sulystring + ", Homerseklet: " + hofokstring + ", Akkumlator: " + akkustring);
tmp.toCharArray(text,150);
GSM.sendSms(number,text);
Köszönöm a segítséget.
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.
Nem.
"ERROR
Sleep mode is enabled
ERROR
Sleep mode is NOT enabled
"
Melyik lábon van most az Rx és Tx?
10-11, bekötés jó,mert SMS-t küld.
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
Nano, <SoftwareSerial.h> , GSM.begin(4800); .
Örülök ha kérdezel.
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!
Gyors kérdés:
Szintillesztőt használsz hozzá? Jól látom, hogy ehhez kellene?
Nem használok. Ez okozhat ilyet? Akkor a többi funkció miért megy?
Igen, azzal kezdtem.
Valami van nálam mostanában a Java-val, mert a Processing sem megy normálisan.
Nem baj, próbálkozom.
Ü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
Erre találták ki az I2C protokollt.
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.
Azzal még nem volt dolgom, de majd utánnanézek...
Mekkorák a távolságok a mester és a szolga eszközök között?
É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...
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.
|
|