Re: Wire.endTransmission w języku c...

2014-06-01T22:30:52+01:00

Ok zamykam.

Statystyki: Napisane przez Micron — 1 cze 2014, o 22:30

Re: Wire.endTransmission w języku c...

2014-06-01T22:13:38+01:00

No to teraz kolega mnie zaskoczył na maxa .... myślałem że chodzi o coś niezwykle nietypowego - ...... o jakąś specyficzną funkcję endTransmission() ..... do jakiegoś tam urządzenia ... nie wiem jakiego - i nie wnikam .... dlatego prosiłem ew o kod źródłowy arduino żeby coś podpowiedzieć .....

zaglądam ci ja sobie do tej biblioteki a tu co ? standardowa biblioteka jakaś do komunikacji I2C .... funkcja (metoda klasy) o której mówisz to dokładnie ta:

[syntax=c]uint8_t TwoWire::endTransmission(uint8_t sendStop) {
// transmit buffer (blocking)
int8_t ret = twi_writeTo(txAddress, txBuffer, txBufferLength, 1, sendStop);
// reset tx buffer iterator vars
txBufferIndex = 0;
txBufferLength = 0;
// indicate that we are done transmitting
transmitting = 0;
return ret;
}[/syntax]

a tu tymczasem "extra" pytanie do całości

Micron napisał(a):

Nie działa mi to za dobrze, gdzie mogę mieć błąd?

No to w czym problem ? czy myślisz że ktoś kto to przeczytał wie o co tobie chodzi w ogóle? o jakie niedziałanie?

- nie działa koledze to w arduino ? czy chodzi o to że nie działa ta funkcja ? czy chodzi o to że przerabiasz sobie całość na C i nie działa ci TYLKO ta funkcja ? czy jak ? ..... sorki ale to masakra .... może jednak warto czasem zadawać bardziej precyzyjnie pytania ? nie sądzisz ? ..... w ten sposób to można w kalambury grać tak w nieskończoność

Bo skąd ja mam wiedzieć gdzie ty możesz mieć jakiś błąd w arduino skoro jak mówiłem nie używam arduino to po pierwsze

Po drugie - nawet gdyby miał ktoś pomóc kto zna arduino to chyba wypadałoby DOKŁADNIE opisać ten cały błąd - pokazać też swój kod jak to używasz czy jak ? ..... A nie pisać -

Quote:

"nie działa mi to, możecie mi powiedzieć gdzie robię błąd?"

no panie kolego .... panie kolego

Jeśli zaś przerabiasz np to już z arduino na C (czego też jakoś wyraźnie nie napisałeś) ... to też - co ci nie działa ? jak przerobiłeś inne funkcje ? inne ci działają ?

Wyżej pokazałem ci tę funkcję a biblioteki arduino o którą pytasz - no ale aż za bardzo nawet nie mogę sobie uzmysłowić - czego w tej funkcji nie rozumiesz ? toż to czysty już kod funkcji w C .... trzeba tylko sobie "opakowanie" do potrzeb swojej biblioteki w C dostosować ... Tyle że wszystkie akurat inne funkcje są wg mnie mega trudniejsze niż ta jedna - a z twojego opisu wynika choć niejasno - że ty już wszystkie przerobiłeś, a została ci tylko ta ? czy jak ?

No to jeśli tylko ta - to oczekiwałem że pojawią się jakieś szczegółowe pytania dotyczące tej funkcji i będzie jakiś ciekawy temat ....

tymczasem - CAŁY WĄTEK to pytanie:

Quote:

"nie działa mi to, dlaczego?"

eeeeeeeh ..... eeeeeeh ..... no tak to nie można ...

---------------------------------------------------------------

Podsumowując - jestem też zdziwiony no ale może jednak nie masz Bluebooka czyli mojej niebieskiej książki:

http://atnel.pl/mikrokontrolery-avr-jezyk-c.html

a może masz? ale też przecież nie napisałeś ...... tymczasem w niej masz WSZYSTKO odnośnie komunikacji I2C wyjaśnione i to w zakresie sprzętowej komunikacji za pomocą modułu TWI jak i sofwarowy przypadek biblioteki - więc po co bujać się z przeróbkami z Arduino ? ..... No chyba że tak dla sportu - to ok - ale też warto to napisać

ostatni raz się tak rozpisałem na TAK zadane pytanie - więcej nie zabiorę głosu przy tak zadawanych pytaniach na forum

Statystyki: Napisane przez mirekk36 — 1 cze 2014, o 22:13

Wire.endTransmission w języku c...

2014-06-01T18:45:14+01:00

Witam. Drodzy forumowicze, jak przerobić ten zapis z Arduino na C
Wire.endTransmission(false); // Send the Tx buffer, but send a restart to keep connection alive
Z góry dziękuje za pomoc.

Może inaczej mam taki zapis:
[syntax=c]uint8_t I2CreadByte(uint8_t address, uint8_t subAddress) {
//uint8_t data; // `data` will store the register data
//Wire.beginTransmission(address); // Initialize the Tx buffer
//Wire.write(subAddress); // Put slave register address in Tx buffer
//Wire.endTransmission(false); // Send the Tx buffer, but send a restart to keep connection alive
//Wire.requestFrom(address, (uint8_t) 1); // Read one byte from slave register address
//data = Wire.read(); // Fill Rx buffer with result
//return data;
}

i zrobiłem taki w c:
uint8_t I2CreadByte(uint8_t address, uint8_t subAddress) {
uint8_t data;
TWI_start();
TWI_write(address);
TWI_write(subAddress);
TWI_start();
TWI_write(address);
data = TWI_read(0);
return data;
}[/syntax]

Kod umieszczamy w znacznikach syntax rezasurmar
Nie działa mi to za dobrze, gdzie mogę mieć błąd?

EDIT: W załączeniu biblioteka arduino wire:

Wire.cpp:

[syntax=c]/*
TwoWire.cpp - TWI/I2C library for Wiring & Arduino
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
*/

extern "C" {
#include
#include
#include
#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);

// Constructors ////////////////////////////////////////////////////////////////

TwoWire::TwoWire()
{
}

// Public Methods //////////////////////////////////////////////////////////////

void TwoWire::begin(void)
{
rxBufferIndex = 0;
rxBufferLength = 0;

txBufferIndex = 0;
txBufferLength = 0;

twi_init();
}

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);
}

uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
{
// clamp to buffer length
if(quantity > BUFFER_LENGTH){
quantity = BUFFER_LENGTH;
}
// perform blocking read into buffer
uint8_t read = twi_readFrom(address, rxBuffer, quantity, sendStop);
// set rx buffer iterator vars
rxBufferIndex = 0;
rxBufferLength = read;

return read;
}

uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity)
{
return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)true);
}

uint8_t TwoWire::requestFrom(int address, int quantity)
{
return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)true);
}

uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop)
{
return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)sendStop);
}

void TwoWire::beginTransmission(uint8_t address)
{
// indicate that we are transmitting
transmitting = 1;
// set address of targeted slave
txAddress = address;
// reset tx buffer iterator vars
txBufferIndex = 0;
txBufferLength = 0;
}

void TwoWire::beginTransmission(int address)
{
beginTransmission((uint8_t)address);
}

//
//Originally, 'endTransmission' was an f(void) function.
//It has been modified to take one parameter indicating
//whether or not a STOP should be performed on the bus.
//Calling endTransmission(false) allows a sketch to
//perform a repeated start.
//
//WARNING: Nothing in the library keeps track of whether
//the bus tenure has been properly ended with a STOP. It
//is very possible to leave the bus in a hung state if
//no call to endTransmission(true) is made. Some I2C
//devices will behave oddly if they do not see a STOP.
//
uint8_t TwoWire::endTransmission(uint8_t sendStop)
{
// transmit buffer (blocking)
int8_t ret = twi_writeTo(txAddress, txBuffer, txBufferLength, 1, sendStop);
// reset tx buffer iterator vars
txBufferIndex = 0;
txBufferLength = 0;
// indicate that we are done transmitting
transmitting = 0;
return ret;
}

//This provides backwards compatibility with the original
//definition, and expected behaviour, of endTransmission
//
uint8_t TwoWire::endTransmission(void)
{
return endTransmission(true);
}

// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(uint8_t data)
{
if(transmitting){
// in master transmitter mode
// don't bother if buffer is full
if(txBufferLength >= BUFFER_LENGTH){
setWriteError();
return 0;
}
// put byte in tx buffer
txBuffer[txBufferIndex] = data;
++txBufferIndex;
// update amount in buffer
txBufferLength = txBufferIndex;
}else{
// in slave send mode
// reply to master
twi_transmit(&data, 1);
}
return 1;
}

// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(const uint8_t *data, size_t quantity)
{
if(transmitting){
// in master transmitter mode
for(size_t i = 0; i < quantity; ++i){
write(data[i]);
}
}else{
// in slave send mode
// reply to master
twi_transmit(data, quantity);
}
return quantity;
}

// must be called in:
// slave rx event callback
// or after requestFrom(address, numBytes)
int TwoWire::available(void)
{
return rxBufferLength - rxBufferIndex;
}

// must be called in:
// slave rx event callback
// or after requestFrom(address, numBytes)
int TwoWire::read(void)
{
int value = -1;

// get each successive byte on each call
if(rxBufferIndex < rxBufferLength){
value = rxBuffer[rxBufferIndex];
++rxBufferIndex;
}

return value;
}

// must be called in:
// slave rx event callback
// or after requestFrom(address, numBytes)
int TwoWire::peek(void)
{
int value = -1;

if(rxBufferIndex < rxBufferLength){
value = rxBuffer[rxBufferIndex];
}

return value;
}

void TwoWire::flush(void)
{
// XXX: to be implemented.
}

// behind the scenes function that is called when data is received
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);
}

// behind the scenes function that is called when data is requested
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();
}

// sets function called on slave write
void TwoWire::onReceive( void (*function)(int) )
{
user_onReceive = function;
}

// sets function called on slave read
void TwoWire::onRequest( void (*function)(void) )
{
user_onRequest = function;
}

// Preinstantiate Objects //////////////////////////////////////////////////////

TwoWire Wire = TwoWire();[/syntax]

Wire.h:

[syntax=c]/*
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
*/

#ifndef TwoWire_h
#define TwoWire_h

#include
#include "Stream.h"

#define BUFFER_LENGTH 32

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();
void begin(uint8_t);
void begin(int);
void beginTransmission(uint8_t);
void beginTransmission(int);
uint8_t endTransmission(void);
uint8_t endTransmission(uint8_t);
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[/syntax]

Statystyki: Napisane przez Micron — 1 cze 2014, o 18:45

ATNEL tech-forum

Re: Wire.endTransmission w języku c...

Re: Wire.endTransmission w języku c...

Wire.endTransmission w języku c...