Merhaba
İki arduino arasında seri haberleşme ile 1 baytlık veri gönderimi yapabiliyorum ama 2 baytlık transferin nasıl yapılacağını bulamadım, mümkün müdür yoksa ben mi ulaşamadım bu bilgiye?
Yazdığım kodda gelen veriyi 0-99 veya 100-255 aralığa göre hafızaya kaydediyorum. Ama daha yüksek veri değeri göndermem ve almam lazım, 2 bayt gibi
Örneğin; ilk hafızaya alacağım değer 0 - 2000, diğeri 2001-15000 gibi...
Teşekkürler.
Şuan alıcıda kullandığım kodlar:
if (Serial.available() > 0)
{
byte GELENVERI = Serial.read();
if (0 < GELENVERI && GELENVERI < 99) {
EEPROM.write(0, GELENVERI);
}
if (100 < GELENVERI && GELENVERI < 255) {
EEPROM.write(10, GELENVERI);
}
}
"Nasıl gönderirim?"sorusuna karşılık bize yardımcı olmak için alıcı kodu mu veriyorsun?
Function tek_gonderim(int gonderilecek)
{
//Tek bayt gönderdiğin kod.
//Not: Tek bayt gönderdiğin kodun değişken parametresine "gonderilecek" yaz.
}
For(j=0;j<2;j++)
{
tek_gonderim(deger[j]);
}
http://subethasoftware.com/2014/12/16/splitting-a-16-bit-value-to-two-8-bit-values-in-c/ (http://subethasoftware.com/2014/12/16/splitting-a-16-bit-value-to-two-8-bit-values-in-c/)
yukarıdaki link üzerinde anlatıldığı gibi
öncelikle kodunu 2 adet 8 bitlik veriye dönüştür.
uint8_t bytes[2];
uint16_t value;
value = 0x1234; //(bu aynı zamanda senin göndereceğin değer)
bytes[0] = value >> 8; // high byte (0x12)
bytes[1] = value & 0x00FF; // low byte (0x34)
baytları ayrı ayrı gönder
aldığın zamanda
value=bytes[0];
value=value<<8;
value |=bytes[1];
örneğin...
if (0 < value && value< 350) {
EEPROM.write(0, value);
}
http://projectsfromtech.blogspot.com/2013/09/combine-2-bytes-into-int-on-arduino.html (http://projectsfromtech.blogspot.com/2013/09/combine-2-bytes-into-int-on-arduino.html)
değişik yöntemler de var.
Alıntı yapılan: erkantr67 - 23 Aralık 2018, 16:03:11"Nasıl gönderirim?"sorusuna karşılık bize yardımcı olmak için alıcı kodu mu veriyorsun?
Function tek_gonderim(int gonderilecek)
{
//Tek bayt gönderdiğin kod.
//Not: Tek bayt gönderdiğin kodun değişken parametresine "gonderilecek" yaz.
}
For(j=0;j<2;j++)
{
tek_gonderim(deger[j]);
}
Cevapladığınız için teşekkür ederim, hocam arduino da yeniyim ya ben eksik anlattım veya sizin yazdığınız kodun inceliğini anlamadım.
Alıcı kodunu verme amacım; kabaca yapmak istediğim düzeni anlatmak içindi, verici düzeneği basit zaten, 8 bitlik bilgiyi gönderiyor ve alıcı arduino ya kaydediyorum. Benim sorunum 16 bitlik (2 baytlık) veriyi gönderim ve almak ile ilgili, sizin yazdığınız kod bununla ilgili ise özür dilerim tam anlayamadım.
Gönderici Arduino da butonlara tanımlı değerler var, butona basıldığında bilgi gidiyor.
Örneğin; verici arduino dan 55 değerini gönderiyorum, alıcı arduino da bunu görüp kaydediyorum ama 255 sonra yani 8 bitten fazlasını nasıl yaparım bilmiyorum.
VERİCİ:
int DEGER = 55;
if (digitalRead(buton1) == LOW) {
Serial.write(DEGER);
}ALICI:
if (Serial.available() > 0) {
int DEGER = Serial.read();
if (0 < DEGER && DEGER< 99) {
EEPROM.write(0, DEGER);
}
}
@Kabil ATICI açıkça anlatmış.
GÖNDERİCİ:unsigned int16 DEGER = 12345; // 16 bitlik değişken oluşturduk.
unsigned int8 on_bellek[2]={0};
if (digitalRead(buton1) == LOW) {
on_bellek[0] = DEGER & 0x00FF; // DEGER 16 bitlik değişkeninin ilk 8 bitini on_bellek'e yükledik.
on_bellek[1] = DEGER >> 8; // DEGER 16 bitlik değişkeninin 8 defa sağa kaydırıp on_bellek'e yükledik.
Serial.write(on_bellek,2); // Serial.write(buf, len) böyle bir kullanım varmış.
}ALICI:
int i=0;
UNSIGNED INT16 DEGER=0;
UNSIGNED INT8 TAMPON[2]={0};
if (Serial.available() > 0)
{
for(i=0;i<2;i++)
{
TAMPON[i] = Serial.read();
}
DEGER=0;
DEGER = TAMPON[1]; // Yüksek değerli veri "DEGER" 16 bitlik değişkenine yüklendi.
DEGER = DEGER << 8; // "DEGER" 16 bitlik değişkeni 8 defa sola kaydırıldı ve kendisine yüklendi.
DEGER |= TAMPON[0]; // Düşük değerli(ilk gelen) veri, "DEGER" 16 bitlik değişkeni ile "veya" işlemine tabi tutuldu.
// Sonrası sana kalmış.
if (0 < DEGER && DEGER< 99)
{
EEPROM.write(0, DEGER);
}
}
Herkese hayırlı günler, yardımlarınız için teşekkürler.
Sizlerin verdiği örneklerde veri gönderimi "ARRAY" dizi şeklinde diye tarif ediliyor, yanılmıyorsam.
Bir de şöyle birşey denedim. Siz ne dersiniz, daha iyi mi yoksa sıkıntılara yol açar mı ileride, denemesini yaptım çalıştı aslında ama fikrinizi almak istedim.
Teşekkürler.
// VERICI:
int DEGER = 65535;
if (digitalRead(BUTON) == LOW) {
while (digitalRead(BUTON) == LOW);
int LOBY = lowByte(DEGER);
int HIBY = highByte(DEGER);
EEPROM.write(0, LOBY);
EEPROM.write(1, HIBY);
Serial.write(HIBY);
delay(5);
Serial.write(LOBY);
delay(5);
Serial.write(1);
delay(5);
}[ / code]
[code]
// ALICI:
int ALANKODU;
if (Serial.available() > 0) {
delay(50);
int HIBY = Serial.read();
delay(5);
int LOBY = Serial.read();
delay(5);
ALANKODU = Serial.read();
delay(5);
if (ALANKODU == 1) {
EEPROM.write(0, LOBY);
EEPROM.write(1, HIBY);
}
if (ALANKODU == 2) {
EEPROM.write(2, LOBY);
EEPROM.write(3, HIBY);
}
}
[ / code]
Gecikme koymamalısın! Alıcı ve verici sistemler birbirinden bağımsız.
Gelen veri boyutu küçük olduğunda neyse de eğer uart tamponunu taşıracak veri alımı yaparsan ileride aynı alım protokolü ile gelen verileri kaçırırsın.
Alıcıyı gelen veriyi gelir gelmez bellekleyecek şekilde düzenlemen iyi olur.
Ve gelen veri bayrağını kontrol eden blok içerisinde sadece bellekleme kodları yer alsın. Hatta veri alımını kesmeyle yapmalısın. Eeprom'a yazma işlemi uart tampodaki bütün veriler ram belleğe yazıldıktan sonra yapılmalı. Böyle sıkıntı olur. Verileri kesmeyle al, ortalık sakinledikten sonra nereye yazarsan yaz.
Şuanki alım şekli uçurumdan aşağı paldur küldür, takla ata ata inen araba gibi.
Hocam gecikmeleri çıkardım, sadece alıcıda 50ms gecikme koydum, 3 veri bilgisinin gelişini tamamlayacak şekilde.
Gönderilen veri boyutu en fazla "30000" verisini geçmeyecek şekilde ayarlandı. Alıcıda kesme fonksiyonu yazdım, burada tüm kodları yazmadım, kalabalık görüntü oluşmasın diye, seri porttan veri geldiğinde kesmeye gidip yukarıda yazdığım alıcı kodunu işleyecek.
Alıntı yapılan: undefinedVe gelen veri bayrağını kontrol eden blok içerisinde sadece bellekleme kodları yer alsın.
Hocam bu dediğinizi tam anlayamadım.
Alıntı yapılan: undefinedEeprom'a yazma işlemi uart tampodaki bütün veriler ram belleğe yazıldıktan sonra yapılmalı.
Ben alıcı kodlarında delay(50) vermemdeki amacım buydu zaten, 3 veride gelsin ve RAM'e kaydedilsin, 50 milisaniye beklesin ve gönderim sırasına göre değişkenlere atansın diye düşündüm ve bu işlemleri seri porttan bilgi geldiği anda kesmeye giderek "kesme fonksiyonu" içerisinde yapacağım. Burada eksik yada yanlış bir uygulama mı yapmış oldum.
//=======================================
// ALICI:
//=======================================
void seri_kontrol() {
if (Serial.available() > 0) {
delay(50); // VERİLERİN TAMAMININ GELMESİNİ BEKLİYORUZ
int HIBY = Serial.read(); // GÖNDERİLEN İLK VERİ HIGHBYTE İDİ
int LOBY = Serial.read(); // GÖNDERİLEN İKİNCİ VERİ LOWBYTE İDİ
int ALANKODU = Serial.read(); // GÖNDERİLEN SON VERİ HANGİ BÖLÜME KAYDEDİLECEĞİ İLE İLGİLİ VERİ
// ALAN KODUNDAKİ VERİYE GÖRE 1. VEYA 2. BÖLÜMDEKİ EEPROM ALANLARINA KAYDEDİLECEK
if (ALANKODU == 1) {
EEPROM.write(0, LOBY);
EEPROM.write(1, HIBY);
}
if (ALANKODU == 2) {
EEPROM.write(2, LOBY);
EEPROM.write(3, HIBY);
}
}
}//=======================================
// VERİCİ:
//=======================================
if (digitalRead(BIRINCI_BUTON) == LOW) { // BİRİNCİ BUTONA BASINCA 25212 VERİSİ GİDECEK
while (digitalRead(BIRINCI_BUTON) == LOW);
int DEGER = 25212;
int LOBY = lowByte(DEGER);
int HIBY = highByte(DEGER);
EEPROM.write(0, LOBY);
EEPROM.write(1, HIBY);
Serial.write(HIBY);
Serial.write(LOBY);
Serial.write(1);
}
if (digitalRead(IKINCI_BUTON) == LOW) { // İKİNCİ BUTONA BASINCA 10812 VERİSİ GİDECEK
while (digitalRead(IKINCI_BUTON) == LOW);
int DEGER = 10812;
int LOBY = lowByte(DEGER);
int HIBY = highByte(DEGER);
EEPROM.write(0, LOBY);
EEPROM.write(1, HIBY);
Serial.write(HIBY);
Serial.write(LOBY);
Serial.write(2);
}Alıntı yapılan: undefinedŞuanki alım şekli uçurumdan aşağı paldur küldür, takla ata ata inen araba gibi.
Yada en başta @Kabil ATICI (https://www.picproje.org/index.php?action=profile;u=30447) ve sizin dediğiniz gibi "DİZİ" şeklindeki kodlamaya mı döneyim?
Saygılar
Oradaki 50ms'yi koymana gerek yok, zaten veri geldikten sonra donanım otomatik olarak "Serial.available() > 0" deyimini "true" yapar. Sizin sadece byte byte çekmeniz gerekir veriyi.
//=======================================
// ALICI:
//=======================================
void seri_kontrol() {
if (Serial.available() > 0)
{
//delay(50); // gerek yok.
int HIBY = Serial.read(); // GÖNDERİLEN İLK VERİ HIGHBYTE İDİ
int LOBY = Serial.read(); // GÖNDERİLEN İKİNCİ VERİ LOWBYTE İDİ
int ALANKODU = Serial.read(); // GÖNDERİLEN SON VERİ HANGİ BÖLÜME KAYDEDİLECEĞİ İLE İLGİLİ VERİ
islem=1;
}
}
Alıntı yapılan: undefinedVe gelen veri bayrağını kontrol eden blok içerisinde sadece bellekleme kodları yer alsın.
Kastım şu; eeprom'a yazma işlemi uzun süren bir işlem. Eğer siz eeprom'a yazma işlemini kesme bloğu içerisinde yaparsanız bir sonraki gelecek bilgi paketini kaçırabilirsiniz. Bu yüzden kesme bloğu içerisinde yeni veri geldiğine dair bir değişkeni uyarırsanız, kesme bloğu içerisinden çıktıktan sonra uyarılan değişkeni ana döngüde kontrol ederek(kontrol edip eeprom'a yazma işlemi) yeni gelebilecek olan bilgi paketinin önünü kesmiş olmazsınız. Tabi bu uyarılacak değişkeni global olarak tanımlamanız gerekli.
void seri_kontrol() {
if (Serial.available() > 0)
{
//delay(50); // Gerek yok.
// Bu uygulamanız için aşağıdaki yazdığınız komutlar sorun olmaz.
// Ama 5 ve üstü gelecek olan veri paketleri için bu şekilde verileri ram belleğe çekmek
// gereksiz hafıza harcamanıza neden olur. Aynı işlemi dizi(array) kullanarak yapabilirsiniz.
int HIBY = Serial.read();
int LOBY = Serial.read();
int ALANKODU = Serial.read();
islem=1;
}
}
Main()
{
for(;;)
{
if(islem==1)
{
islem=0;
// ALAN KODUNDAKİ VERİYE GÖRE 1. VEYA 2. BÖLÜMDEKİ EEPROM ALANLARINA KAYDEDİLECEK
if (ALANKODU == 1)
{
EEPROM.write(0, LOBY);
EEPROM.write(1, HIBY);
}
if (ALANKODU == 2)
{
EEPROM.write(2, LOBY);
EEPROM.write(3, HIBY);
}
}
}
}
Seri bilgiden gelen ilk byte
hangisi olduğunu anlayabilmek
için en az iki karakter boş
bilgi yollamanız da gerekli
bence.
Mrb arkadasla aradan uzun zaman geçmiş ama yeniden konu açmak istemedim.
Problemim şu Slav arduinodan bir 16 bitlik değişkeni master arduino ya göndermek istiyorum ancak o kadar ugrasmama rağmen yapamadim ve en son aklıma şöyle bir durum geldi
16 bitlik değişkenin Max 3000 değerini alıyor.
Ben bu değeri sabit bir değerle bölerek 255 in altında karşıya göndersem ve karşı tarafta da gelen veriyi yine aynı sabit sayı ile çarparak asıl sayıya ulassam sorun yaratır mı, bölme işlemi float olacak ve fload değer serial den gönderilecek
Soyle yap.
Gondermek istedigin sayi x
H = x/128
L = X - (H*128)
H = H OR 128
Simdi H ve L yi yolla.
Pespese aldigin 2 byte veriden
8. biti 1 olan H
8. biti 0 olan da L dir.
X sayisini geri elde edebilmek icin X=(H and 127)*128 + L
Eğer ekleyeceğin ekstra bytelar sıkıntı olmazsa
NMEA 0183 benzeri bir yapı kullanabilirsin.
Örnek :
$AYXDR,VERI1,VERI2*XX
XX kısmı checksum, verinin doğruluğunu da kontrol etmiş olursun.
kimlenbu üstadım ("NMEA 0183") bu kısmı anlamadım.
8 bit veride sorunum yok aktarabiliyorum ancak 16 bit göndermem gerekiyor
gönderici kodlarım
button=digitalRead(buton); //butona basıldı ise seri porttan veri gönder
if (button==0)
{
high=highByte(sayac);
low=lowByte(sayac);
Serial.write(low); //8 bit bu bölümü mastera gönderip alabiliyorum
Serial.write(high); //msb kısmını çözemedim
}
alıcı kodlarım
void serialEvent() {
digitalWrite(a,LOW);
byte a=0;
if (Serial.available() > 0)
{
a= Serial.read();
box.clear();
box.print(a);
}
}
bu sekilde 1 byte veri aktarabiliyorum ama 2 byte lık veriyi çözemedim
https://www.mehmetbilgi.net.tr/arduino-ile-seri-port-uzerinden-7-segment-display/
İşe yarar belki.
mehmet ustam linke tıkladım. baktım olmuyor neşet ertaş açtım efkarlanıyorum. pes etmeyeceğim ama iyice karamsarlığa gömüldüm.
saat 6 ve çözdüm ama çok saçma
gönderici
Serial.write(low);
Serial.write(high);
alıcı
void serialEvent() {
digitalWrite(a,LOW);
byte a=0;
if (Serial.available() > 0)
{
low= Serial.read();
high= Serial.read();
sayac=high;
sayac=sayac<<8;
sayac |=low;
}
}
Kodun tamamı buysa sanki olmaz gibi.. Yanlış anlamadıysam " a " değişkenine önce yazıyorsunuz sonra siliyorsunuz.. kodun mantığı hakkında biraz açıklama yapabilirseniz biz de yararlanabiliriz..
Alıntı yapılan: interrupter - 04 Ocak 2022, 06:03:52çözdüm ama çok saçma
Saçma olan neresi? Kod gayet mantıklı. I2C'de benzer işlemler yapıyoruz 16 bit ve üzeri verilerde.
Bu lojikte MSB (Most Significant Bit- En Önemli Bit) ve LSB (Least Significant Bit- En Az Önemli Bit) mantığında geçer.
16bitlik verinin ilk 8 biti MSB, sonraki 8 bitlik kısmı LSB'dir.
8 Bitlik register'ı olan bir donanım bunu tek satırda tutamaz. Kaldı ki halen birçok iletişim protokolü de 8 bit yani bayt üzerine kuruludur.
16 bitlik veriyi parçalamanın kolay yolu. 1111111100000000 veya 0000000011111111 ile and işlemine tabi tutabilirsin.
8'er bitten toplarken de 8 kez shift edip or işlemine tabi tutabilirsin.
Mg1980 a ya bişey kaydedilmiyor o kadar uğraştım ki a kalmış orada. Gelen veriler low ve high değişkenine geliyor. Sistemim şöyle 7 adet slave arduiono nanom var birde master olarak Arduino Megan var Arduino mega sırası ile nanolarin bir digital pimini high yapıyor ve nanolarda belirli inputu high olunca seri porttan 2 byte veri gonderecek. Benim mantığını kuramadigim konu şu idi slaveden iki ayrı değişken gonderdigimde master tarafı iki kez serial kesme işlemine girecek diye düşünüyordum ama öyle değilmiş. Nanodan 2 byte gönderiyorum master bir kez kesmeye giriyor ve serial.read ile kesme içinde okuyorum. Olay basitmiş ama ben geç farkettim
sorunlarım bir bitmiyor kafayı yedim simdiiki sorunumda su while ın içerisindeki iken serial kesme nedengirmez;
void loop()
{
while(level==1)
{
box.clear();
box.print(sayac);
delay(100);
}
delay(1000);
}
void serialEvent() {
digitalWrite(a,LOW);
byte sonuc=0;
if (Serial.available() > 0)
{
low= Serial.read();
high= Serial.read();
sonuc=Serial.read();
sayac=high;
sayac=sayac<<8;
sayac |=low;
if(sonuc==67)
{
level++;
}
}
}
delay(1000) ,i mesela 1ms,lik for döngüsü şeklinde yazıp dener misiniz.. keza delay(100) de..
Alıntı yapılan: interrupter - 05 Ocak 2022, 04:08:09simdiiki sorunumda su while ın içerisindeki iken serial kesme nedengirmez
serialEvent fonksiyonu gerçek bir interrupt olmadığından olabilir mi?
Arduino'da interrupt'ı kullanmanın tek yolu AVR komutları ile yazmaktan geçer.
Nasıl?
#include <avr/interrupt.h>
#include <avr/io.h>
inceleyin.
Döngü içinde
yield(); komutunu kullanıp deneyin bir de.
sayın mühendis bey kusuruma bakmayın kesmenin yalanı gerçeği mi olur. foruma göre çok acemiyim.
void setup() içinde kesme ayarlarını yapıyor musunuz?
mg ustam bilmiyorum işte o kadar bilgim yok arastırıyorum ama bisey bulamadım bikaç bisey buldum onlarda ya hata veriyor yada tepki vermiyor.
Siz hallettim dediğiniz için kodunuzun tamamını koymak istemediğinizi düşünmüştüm. Ben de çok uzman değilim ama biraz denemeler yapmıştım, şu anda dışardayım, bilgisayarı açtığımda benzer bir şey göndermeye çalışırım.
Ustam slave den 16 bir veriyi gönderip masterden alabiliyorum.ama loop un içinde 5 tane ayrı while oluşturuyorum her while de bir slavenin inputunu lojik 1 yapıyorum. Slave seri veriyi gönderiyor ama master while nin içinde kaliyor. Serial event fonksiyonu kesme işlemi yapmıyor. Serialport kesmesi oluştuğunda seriden gelen veriyi alacağım ve while şartını bir diğer while in şartına arayacağım
Bu biraz ileri seviye bir iş... ben olsam önce iki arduino arasında bu işi basit bir şekilde yapar, kesmenin çalıştığını, veri alınıp gönderilebildiğini tam anlamıyla gördükten sonra sizin dediğiniz boyuta yükseltirdim işi... siz nasıl yaptınız bilemiyoruz.. çalışan kodunuzu da tam olarak koyarsanız yardımcı olabilecek daha iyi bilenlerimiz çıkabilir..
Aynen ustam dediğiniz gibi yapıyorum zaten tek while nin içinden cikabilsem kodumun tamamı en son gyzdigim zaten kesme işlemini test ediyorum ama kesmeye giremedim
#include <avr/io.h>
#include <SPI.h>
#include <DMD2.h>
#include <fonts/Arial_Black_16.h>
#define USART_BAUDRATE 9600
byte a=31,b=29,c=27,d=25,e=23,f=21,g=19;
SoftDMD dmd(2,1); // DMD controls the entire display
DMD_TextBox box(dmd, 0, 1); // "box" provides a text box to automatically write to/scroll the display
void setup() {
UBRR0L = USART_BAUDRATE & 0xff;
UBRR0H = USART_BAUDRATE >> 8;
UCSR0C |= (1 << UCSZ00) | (1 << USBS0); // Use 8-bit character sizes
UCSR0B |= (1 << RXEN0) | (1 << TXEN0) | (1 << RXCIE0); // Turn on the transmission, reception, and Receive interrupt
interrupts();
Serial.begin(9600);
dmd.setBrightness(25);
dmd.selectFont(Arial_Black_16);
dmd.begin();
pinMode(a, OUTPUT);
digitalWrite(a,LOW);
}
void loop()
{
digitalWrite(a,HIGH);
delay(30);
digitalWrite(a,LOW);
}
ISR(USART0_RXC)
{
box.clear();
box.print("veriii");
UDR0 = 1;
delay(100); // wait for a second
}
mg ustam kodun tamamı böyle su anda tek amacım kesme oluşup oluşmadığını test etmeye çalışıyorum ama oluşturamadım daha
Global bir int enable disable durumu yokmu bu islemcide?
z hocam sorduğnuz soruya cevabım olacak kapasitede bilgim olsa... öğrenmeye çalışıyorum
Bu kod sanırım, bir kaç yerden toparlanmış ve karışık bir hal almış gibi.. mesela "a" başlangıçta byte değişken olarak atanmış ve 31 değeri verilmiş.. sonra setup, da pin yapılandırması gibi çıkış yapılıp LOW, HIGH yapılıyor.. loop içinde blink yaptırılıyor, orada da bir delay eksik, yani pin yapılandırması olsa devamlı yanar.. belki de ben yanlış değerlendiriyorum, arduino mantığına pek uygun gibi gelmedi bana... fazla uzman olmadığımı söyledim.. kendi işlerimi görecek kadar.. hocalarımız daha iyi değerlendirebilir..
mg ustam kod toplama değil seri port kesmesi toplama çünkü bilmiyorum mantığını anlamadım örnek bulamadım.
a değişkeni tanımladım ve içeriğini 31 yaptım çünkü benim arduino mega karttımın 31 numaralı pini benim slave 1 kartımın bilgi gönder pinine denk geliyor.
a değişkenine 31 yazdım
a yı çıkış olarak atadım yani 31 numaralı pini
loop ta da
a pinini high low yapıyorum.
çünkü her bu pindeki her palste slave seri veri gönderiyor.
ve seri porttan verii gelmeye başladığı anda master kesmeye girmesi lağzım ama seri kesmeyi yapamadım
seri porttan verii geliyor ama kesmeye sokamıyorum
Alıntı yapılan: interrupter - 05 Ocak 2022, 17:41:41uma bakmayın kesmenin yalanı gerçeği mi olur. foruma göre çok acemiyim.
Yalan, gerçek mevzusu değil. Arduino'nun seri iletişim kütüphanesinde kesme yoktur. Kesmeye benzer mantıkta çalışan kodlar türetilmiştir, ancak bu da her koşulda kesme gibi kullanabilmenizi sağlamaz. serialEvent'in while içerisinde çalışmaması gibi...
O nedenle bazen AVR kodları ile müdahale ederiz. Örneğin; çok küçük gecikme oluştururken, pinleri hızlı toggle ederken; farklı, özel frekanslarda PWM oluştururken...
Anladım sayın muhendisbey. Yani Arduinoda (atmega 328p) için konuşuyorum seri port donanımsal kesme yok adamlar yazılımsal serialevent yapmışlar bu da bu şekilde çalışıyor. Örneğin o kadar serial kesme için doküman aradım ama yok bulamadim hep harici kesme (dijital pinlerle) yada dahili kesmeler var. Sorunuma tekrar gelecek olursam kesmeye çok kafayı takmışım farklı yöntemle kesmesiz hallettim. Ama bu kesme meselesini kafaya taktım. Sizler nasıl yapıyorsunuz
Eğer bir arduino projesi ise çoğunlukla kesmeye ihtiyaç olmadan çözmeye çalışırım. Bir veri geliyorsa o veriyi kısa sürede işleyip, ya da gelen veri çoksa buffer'a alıp işlerim. Ancak bu da her zaman çözüm olmaz.
Echo yapmıyorsun ki bu sıkıntının kaynağı burada yatıyor. Echo yaparsan veri gönderildiğinde bu veriyi değişkene kaydedip geri gönderirsin ve verinin alındığından emin olursun. Geri gelmemişse veri, tekrar gönderirsin. Handshake denir bu işleme.
Proje büyükse, bu işi arduino ile değil, tiva ya da STM ile gerçekleştiririm. Vector table'ını ayarlar, kesmelerini ayarlar, ring buffer oluşturarak yaparım.
Arduino ile ilerleyeceksen:
14. yorum:
https://www.avrfreaks.net/forum/atmega328p-serial-communication-interrupt
ya da
https://stackoverflow.com/questions/53104440/how-to-implement-interrupt-for-serial-usart-communication-for-atmega328p-arduino
datasheet'i detaylı okumak gerekli.
Atmega 328p seri port(uart) ilgili örnekleri (datasheet) veri kağıtlarında asm ve c kod olarak bulunmaktadır.
Arduino kodu olarak da çalışmaktadır.
@interrupter ve değerli arkadaşlar,
İşinize yarar mı bilmiyorum ama Arduino'da olmayan USART-donanımsal kesme ile ilgili bir çalışma yaptım.Benzeri var mı bilmiyorum, bir yerden alıntı değil ve fiilen denedim, çalışıyor. Kodları ile ilave yapılacak basit bir devre fotoğrafını aşağıya koyuyorum. Bilindiği gibi Arduino Uno-Nano'da External Kesme denen bir olay var. Buna ait pinler 2 ve 3 no.lu pinler. 2 no.lu harici kesme pinini bir transistör ile PULLUP yaparak INT0 (pin2) pinine bağladım.Rx (0 pini) 'ni de 27k direnç ile transistör beyz'ine verdim.Kendi seri portu üzerinden PC'den veri gönderip aldım gayet güzel çalışıyor.Şimdilik problem görünmüyor.İki Arduino arasında denendiğinde problem gören olursa birlikte çözüm ararız.
const int LED=8;
const int LEDX=13;
volatile double deneme;
volatile double gelen;
void setup()
{
Serial.begin(9600);
pinMode(LED,OUTPUT);
pinMode(LEDX,OUTPUT);
pinMode(2,INPUT);
digitalWrite(LED,LOW);
digitalWrite(LEDX,LOW);
attachInterrupt(0,kesme,FALLING); //RISING=Yükselen kenar,FALLING..düşen
}
void loop()
{
digitalWrite(LEDX,HIGH);
delay(500);
digitalWrite(LEDX,LOW);
delay(500);
digitalWrite(LED,LOW);
}
void kesme() // Kesme fonksiyonu
{
cli(); // Fonksiyon boyunca tekrar kesme oluşmaması için....KESME'yi KAPAT..
if(Serial.available()>0) // Seri porta veri geldiyse
{
gelen=Serial.read();
digitalWrite(LED,HIGH);
Serial.println(gelen);
deneme=65535;
Serial.println(deneme);
}
sei(); // KESME'yi AÇ..
}
(https://i.ibb.co/Fg5BktN/Whats-App-Image-2022-01-15-at-12-47-49.jpg) (https://ibb.co/Fg5BktN)
Mg1980 başa cikamazsam bende böyle düşünüyordum ama mantigimi değiştirerek hallettim. Bazı denemeler yapıyorum kod üzerinde ve burada da paylasacagim
#include <avr/io.h>
#include <SPI.h>
#include <DMD2.h>
#include <fonts/Arial_Black_16.h>
#define USART_BAUDRATE 9600
unsigned int sayac=0, toplam=0, sys=0,slva=0,slvb=0,slvc=0,slvd=0,slve=0,slvf=0,slvg=0;
byte level=1,a=29,b=27,c=25,d=23,e=21,f=19,g=17,bosalt=0;
byte low=0,high=0;
bool aa=0,bb=0,cc=0,dd=0,ee=0,ff=0,gg=0,interrupt=0;
bool stringComplete = false;
SoftDMD dmd(2,1); // DMD controls the entire display
DMD_TextBox box(dmd, 0, 1); // "box" provides a text box to automatically write to/scroll the display
void setup() {
Serial.begin(9600);
dmd.setBrightness(100);
dmd.selectFont(Arial_Black_16);
dmd.begin();
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
}
void loop()
{
if(aa==1)
{
slva=0;
aa=0;
DMD_TextBox box(dmd, 45, 0);
box.print("A");
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(500);
}
if(bb==1)
{
slvb=0;
bb=0;
DMD_TextBox box(dmd, 45, 0);
box.print("B");
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(500);
}
if(cc==1)
{
slvc=0;
cc=0;
DMD_TextBox box(dmd, 45, 0);
box.print("C");
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(500);
}
if(dd==1)
{
slvd=0;
dd=0;
DMD_TextBox box(dmd, 45, 0);
box.print("D");
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(500);
}
if(ee==1)
{
slve=0;
ee=0;
DMD_TextBox box(dmd, 45, 0);
box.print("E");
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(500);
}
if(ff==1)
{
slvf=0;
ff=0;
DMD_TextBox box(dmd, 45, 0);
box.print("F");
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(500);
}
if(gg==1)
{
slvg=0;
gg=0;
DMD_TextBox box(dmd, 45, 0);
box.print("G");
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(500);
}
toplam=slva+slvb+slvc+slvd+slve+slvf+slvg;
box.clear();
box.print(toplam);
if (Serial.available() > 0)
{
bosalt=Serial.read();
}
else
{
if(level==1)
{
aa=1;
slva=0;
digitalWrite(a,HIGH);
}
if(level==2)
{
bb=1;
slvb=0;
digitalWrite(b,HIGH);
}
if(level==3)
{
cc=1;
slvc=0;
digitalWrite(c,HIGH);
}
if(level==4)
{
dd=1;
slvd=0;
digitalWrite(d,HIGH);
}
if(level==5)
{
ee=1;
slve=0;
digitalWrite(e,HIGH);
digitalWrite(e,HIGH);
}
if(level==6)
{
ff=1;
slvf=0;
digitalWrite(f,HIGH);
}
if(level==7)
{
gg=1;
slvg=0;
digitalWrite(g,HIGH);
}
delay(1000);
level++;
if(level>=8) level=1;
}
}
void serialEvent() {
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
byte sonuc=0;
high=0;
low=0;
sayac =0;
if (Serial.available() > 0)
{
low= Serial.read();
high= Serial.read();
sonuc=Serial.read();
sayac=high;
sayac=sayac<<8;
sayac |=low;
high=0;
low=0;
if(sonuc==67)
{
sonuc=0;
if(aa==1){
aa=0;
slva=sayac;
sayac=0;
}
if(bb==1){
bb=0;
slvb=sayac;
sayac=0;
}
if(cc==1){
cc=0;
slvc=sayac;
sayac=0;
}
if(dd==1){
dd=0;
slvd=sayac;
sayac=0;
}
if(ee==1){
ee=0;
slve=sayac;
sayac=0;
}
if(ff==1){
ff=0;
slvf=sayac;
sayac=0;
}
if(gg==1){
gg=0;
slvg=sayac;
sayac=0;
}
}
}
}
İyi günler arkadaşlar,
Arduino Uno ile desimal 5 basamak yukarıda sunulan ilave devre ile external kesme yoluyla veri alımı denenen gönderici ve alıcı kodları aşağıdadır. Bazı arkadaşların işine yarayabilir.
GÖNDERME KODLARI:
//USART GÖNDERME ARDUİNO UNO..
//BU PROGRAM ARDUİNO UNO İLE USART HABERLEŞME GÖNDERME ÜNİTESİDİR.Çalışmada kullanılan bazı fazlalıklar silinmemiştir.LED vs.
const int BUTON1=4;
const int BUTON2=5;
const int BUTON3=3;
const int BUTON4=6;
const int LED=8;
const int LEDY=9;
const int LEDZ=10;
const int LEDX=13;
volatile unsigned long gonder; //32 bit işaretsiz
volatile unsigned long gelen;
void setup()
{
Serial.begin(9600);
pinMode(BUTON1,INPUT_PULLUP);
pinMode(BUTON2,INPUT_PULLUP);
pinMode(BUTON3,INPUT_PULLUP);
pinMode(BUTON4,INPUT_PULLUP);
pinMode(2,INPUT);
pinMode(LEDY,OUTPUT);
pinMode(LEDZ,OUTPUT);
pinMode(LED,OUTPUT);
pinMode(LEDX,OUTPUT);
digitalWrite(LED,LOW);
digitalWrite(LEDX,LOW);
digitalWrite(LEDY,LOW);
digitalWrite(LEDZ,LOW);
}
void loop()
{
if(digitalRead(BUTON1)==LOW){
gonder=12;
delay(2000); // Buton paraziti için fazlaca yazılmıştır.
Serial.print(gonder); //Serialwrite komutu göndermede çalışmıyor,karışık işaretler oluşuyor.!!!!!
}
if(digitalRead(BUTON2)==LOW){
gonder=123;
delay(2000);
Serial.print(gonder);
}
if(digitalRead(BUTON3)==LOW){
gonder=1234;
delay(2000);
Serial.print(gonder);
}
if(digitalRead(BUTON4)==LOW){
gonder=12345;
delay(2000);
Serial.print(gonder);
}
digitalWrite(LEDX,HIGH); //blink için
for(int i=0;i<50;i++){
delay(1);
}
digitalWrite(LEDX,LOW);
for(int i=0;i<50;i++){
delay(1);
}
}
ALMA KODLARI:
//USART KESME..ALICI...ARDUİNO UNO...
// BU PROGRAM ALICI ARDUİNO TARAFIDIR.İŞLEM SONUCU PC'DE SERİAL MONİTÖRDE GÖRÜLEBİLİR.BUTON,LED GİBİ FAZLALIKLAR SİLİNMEMİŞTİR.
// YAPILAN TRANSİSTÖLÜ DEVRE SAYESİNDE EXTERNAL İNTERRUPT İLE desimal 5 basamak veri alınmıştır.Daha fazlası denenmemiştir.
const int BUTON1=4;
const int BUTON2=5;
const int LED=8;
const int LEDY=9;
const int LEDZ=10;
const int LEDX=13;
volatile unsigned long gonder; //32 bit işaretsiz
volatile unsigned long gelen;
volatile unsigned long silme;
boolean t;
void setup()
{
Serial.begin(9600);
pinMode(BUTON1,INPUT_PULLUP);
pinMode(BUTON2,INPUT_PULLUP);
pinMode(2,INPUT);
pinMode(LEDY,OUTPUT);
pinMode(LEDZ,OUTPUT);
pinMode(LED,OUTPUT);
pinMode(LEDX,OUTPUT);
digitalWrite(LED,LOW);
digitalWrite(LEDX,LOW);
digitalWrite(LEDY,LOW);
digitalWrite(LEDZ,LOW);
attachInterrupt(0,kesme,CHANGE); //RISING=Yükselen kenar,FALLING..düşen
}
void loop()
{
if(t==1){
while(Serial.available()>0){
gelen=Serial.read();
Serial.write(gelen);
t=0;
gelen=0;
}
delayMicroseconds(1);
attachInterrupt(0,kesme,CHANGE);
}
digitalWrite(LEDX,HIGH); //blink için
for(int i=0;i<500;i++){
delay(1);
}
digitalWrite(LEDX,LOW);
for(int i=0;i<500;i++){
delay(1);
}
}
void kesme() // Kesme fonksiyonu
{
detachInterrupt(0);// Fonksiyon boyunca tekrar kesme oluşmaması için....KESME'yi KAPAT..
t=1;
}