Aşağıda Arduino'nun özgün dilini kullanarak basit bir pulse jeneratör kodu bulunmaktadır: Bu kod saysesinde bir Step Motor Sürücü yada bir Servo Motor sürücü rahatlıkla çalıştırılabilir. Bilgisayar veya pnc v.b kart gereğini ortadan kaldıran basit uygulamalar için kullanılabilir.
// Pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int pulseWidth = 500; // Pulse genişliği (milisaniye cinsinden)
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
}
void loop() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
Yukarıdaki kod, Arduino'nun 9. pinini kullanarak bir pulse jeneratör oluşturur. Bu pin, pulse sinyalinin çıkışını sağlar. pulseWidth değişkeni, pulse genişliğini belirler ve burada 500 milisaniye (0.5 saniye) olarak ayarlanmıştır. Ardından, setup() fonksiyonunda çıkış pinini ayarlayarak işleme başlanır.
loop() fonksiyonu, pulse sinyalini sürekli olarak oluşturur. digitalWrite() fonksiyonu kullanılarak çıkış pinine yüksek (HIGH) değer verilerek pulse başlatılır. Ardından, delayMicroseconds() fonksiyonu kullanılarak pulse genişliği kadar bekleme yapılır. Daha sonra, digitalWrite() fonksiyonuyla çıkış pinine düşük (LOW) değer verilir ve pulse sonlandırılır. Son olarak, delay() fonksiyonuyla bir sonraki pulse arasında 1 saniye bekleme yapılır.
Bu kodu Arduino'ya yükleyerek pulse jeneratörü işlevini gerçekleştirebilirsiniz. Pulse genişliğini ve bekleme sürelerini ihtiyaçlarınıza göre ayarlayabilirsiniz. Ayrıca, pulse sinyalini farklı bir pin üzerinden çıkış yapmak isterseniz, outputPin değişkenini kullanmak istediğiniz pin numarasına göre güncelleyebilirsiniz.
// Potansiyometre ile hız ayarlı pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int potentiometerPin = A0; // Potansiyometre bağlı olan Arduino pin numarası
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
}
void loop() {
int pulseWidth = analogRead(potentiometerPin); // Potansiyometre değerini oku (0-1023 aralığında)
pulseWidth = map(pulseWidth, 0, 1023, 0, 1000); // Potansiyometre değerini 0-1000 aralığına dönüştür
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
Yukarıdaki kodda, potansiyometrenin sinyali Arduino'nun Analog 0 (A0) pinine bağlanır. Potansiyometre tarafından okunan değer pulse genişliğini belirler. Ardından, analogRead() fonksiyonu kullanılarak potansiyometrenin değeri okunur ve 0 ile 1023 arasında bir değer elde edilir.
map() fonksiyonu kullanılarak potansiyometre değeri 0-1000 aralığına dönüştürülür. Bu, pulse genişliği olarak kullanılacak mikrosaniye cinsinden bir değeri temsil eder. Yani, potansiyometre değeri arttıkça pulse genişliği artar ve pulse hızı yavaşlar.
Daha sonra, digitalWrite() fonksiyonu kullanılarak çıkış pinine yüksek (HIGH) değer verilerek pulse başlatılır. delayMicroseconds() fonksiyonu kullanılarak pulse genişliği kadar bekleme yapılır. Ardından, digitalWrite() fonksiyonuyla çıkış pinine düşük (LOW) değer verilir ve pulse sonlandırılır. Son olarak, delay() fonksiyonuyla bir sonraki pulse arasında 1 saniye bekleme yapılır.
Bu şekilde, potansiyometre ile pulse genişliğini ayarlayarak hız ayarlı bir pulse jeneratörü oluşturabilirsiniz.
// Yön kontrollü pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int buttonPin1 = 2; // İleri yön butonu için Arduino pin numarası
const int buttonPin2 = 3; // Geri yön butonu için Arduino pin numarası
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(buttonPin1, INPUT_PULLUP); // İleri yön butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(buttonPin2, INPUT_PULLUP); // Geri yön butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
if (digitalRead(buttonPin1) == LOW) { // İleri yön butonuna basıldığında
pulseWidth += 100; // Pulse genişliğini artır
}
if (digitalRead(buttonPin2) == LOW) { // Geri yön butonuna basıldığında
pulseWidth -= 100; // Pulse genişliğini azalt
}
// Pulse genişliğini sınırla (0-1000 aralığında tut)
if (pulseWidth < 0) {
pulseWidth = 0;
}
if (pulseWidth > 1000) {
pulseWidth = 1000;
}
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
Yukarıdaki kodda, iki buton kullanılarak pulse genişliği yönlendirilir. buttonPin1, ileri yön butonu olarak tanımlanırken, buttonPin2, geri yön butonu olarak tanımlanır. Butonlar Arduino'nun digital pinlerine bağlanır ve dahili pull-up direnci etkinleştirilir.
loop() fonksiyonunda, digitalRead() fonksiyonu kullanılarak butonların durumu okunur. Eğer ileri yön butonuna basılırsa, pulse genişliği 100 birim artırılır. Eğer geri yön butonuna basılırsa, pulse genişliği 100 birim azaltılır.
Ardından, pulse genişliği belirli aralıklarla sınırlanır. Bu örnekte, pulse genişliği 0 ile 1000 arasında tutulur.
Daha sonra, digitalWrite() fonksiyonu kullanılarak çıkış pinine yüksek (HIGH) değer verilerek pulse başlatılır. delayMicroseconds() fonksiyonu kullanılarak pulse genişliği kadar bekleme yapılır. Ardından, digitalWrite() fonksiyonuyla çıkış pinine düşük (LOW) değer verilir ve pulse sonlandırılır. Son olarak, delay() fonksiyonuyla bir sonraki pulse arasında 1 saniye bekleme yapılır.
Bu şekilde, ileri ve geri yön butonlarıyla kontrol edilebilen bir yön kontrollü pulse jeneratörü oluşturabilirsiniz. Pulse genişliğini artırmak veya azaltmak için butonları kullanabilirsiniz.
Aşağıda, Arduino kullanarak toogle (geçiş) butonu ve yön değiştiren potansiyometre ile hız ayarlı bir pulse jeneratörü yapımını gösteren bir örnek kod bulunmaktadır:
-----------------------------------------------------------------------
// Toggle buton ve yön değiştiren potansiyometre ile hız ayarlı pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int toggleButtonPin = 2; // Toggle butonu için Arduino pin numarası
const int potentiometerPin = A0; // Potansiyometre bağlı olan Arduino pin numarası
bool isForward = true; // İleri yön kontrolü
bool toggleState = false; // Toggle buton durumu
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(toggleButtonPin, INPUT_PULLUP); // Toggle butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Toggle butonunun durumunu oku
if (digitalRead(toggleButtonPin) == LOW) {
toggleState = !toggleState; // Durumu tersine çevir
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// İleri veya geri yönü belirle
if (toggleState) {
isForward = !isForward; // Toggle butonuna bağlı olarak yönü değiştir
}
// Potansiyometre değerini oku ve pulse genişliğini ayarla
int potValue = analogRead(potentiometerPin);
pulseWidth = map(potValue, 0, 1023, 100, 1000); // Potansiyometre değerini 100-1000 aralığına dönüştür
// Pulse jeneratörünü çalıştır
if (isForward) {
forwardPulse();
} else {
reversePulse();
}
}
// İleri yönde pulse jeneratörü
void forwardPulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
// Geri yönde pulse jeneratörü
void reversePulse() {
digitalWrite(outputPin, LOW); // Pulse başlangıcında çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, HIGH); // Pulse sonunda çıkış pinini yüksek yap
delay(1000); // Pulse arasında 1 saniye bekle
}
```
Yukarıdaki kodda, Arduino'nun 2. pinine bağlı olan toogle (geç
iş) butonu ile pulse jeneratörünün yönünü değiştirebilirsiniz. Ayrıca, pulse hızını ayarlamak için bir potansiyometre kullanıyoruz. İleri ve geri yönler arasında geçiş yapmak için toogle butonu kullanılırken, potansiyometre pulse genişliğini ayarlamak için kullanılır.
Kodun `setup()` fonksiyonunda çıkış pinini, toggle butonunu ve potansiyometreyi ayarlıyoruz.
`loop()` fonksiyonunda, toggle butonunun durumunu okuyoruz. Eğer butona basıldıysa, toggle durumunu değiştiriyoruz. Ayrıca, potansiyometrenin değerini okuyarak pulse genişliğini belirliyoruz.
Daha sonra, `forwardPulse()` ve `reversePulse()` fonksiyonlarını kullanarak ileri veya geri yönde pulse jeneratörünü çalıştırıyoruz. İleri yönde pulse jeneratörü çalıştığında çıkış pini yüksek (HIGH) olacakken, geri yönde pulse jeneratörü çalıştığında çıkış pini düşük (LOW) olacaktır.
Bu şekilde, toggle butonu ve yön değiştiren potansiyometre ile kontrol edilebilen hız ayarlı bir pulse jeneratörü oluşturabilirsiniz.
Aşağıda, Arduino kullanarak iki butonla hızı artıran ve azaltan bir pulse jeneratörü yapımını gösteren bir örnek kod bulunmaktadır:
-----------------------------------------------------------------------
// İki buton ile hız arttıran ve düşüren pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int increaseButtonPin = 2; // Hızı artıran buton için Arduino pin numarası
const int decreaseButtonPin = 3; // Hızı düşüren buton için Arduino pin numarası
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
int increment = 100; // Hız artış miktarı
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(increaseButtonPin, INPUT_PULLUP); // Hız artıran butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(decreaseButtonPin, INPUT_PULLUP); // Hız düşüren butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
if (digitalRead(increaseButtonPin) == LOW) { // Hız artıran butona basıldığında
pulseWidth += increment; // Pulse genişliğini artır
}
if (digitalRead(decreaseButtonPin) == LOW) { // Hız düşüren butona basıldığında
pulseWidth -= increment; // Pulse genişliğini azalt
}
// Pulse genişliğini sınırla (minimum 0, maksimum 1000 aralığında tut)
if (pulseWidth < 0) {
pulseWidth = 0;
}
if (pulseWidth > 1000) {
pulseWidth = 1000;
}
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
```
Yukarıdaki kodda, iki buton kullanılarak pulse genişliği (hız) ayarlanır. `increaseButtonPin`, hızı artıran buton olarak tanımlanırken, `decreaseButtonPin`, hızı düşüren buton olarak tanımlanır. Butonlar Arduino'nun dijital pinlerine bağlanır ve dahili pull-up direnci etkinleştirilir.
`loop()` fonksiyonunda, `digitalRead()` fonksiyonu kullanılarak butonların durumu okunur. Eğer hızı artıran butona basılırsa, pulse genişliği `increment` miktarı kadar artırılır. Eğer hızı düşüren butona basılırsa, pulse genişliği `increment` miktarı kadar azaltılır.
Pulse genişliği belir
li aralıklarla sınırlanır. Bu örnekte, pulse genişliği 0 ile 1000 arasında tutulur.
Daha sonra, `digitalWrite()` fonksiyonu kullanılarak çıkış pini yüksek (HIGH) değerine ayarlanarak pulse başlatılır. `delayMicroseconds()` fonksiyonu kullanılarak pulse genişliği kadar bekleme yapılır. Ardından, `digitalWrite()` fonksiyonuyla çıkış pini düşük (LOW) değerine ayarlanarak pulse sonlandırılır. Son olarak, `delay()` fonksiyonuyla bir sonraki pulse arasında 1 saniye bekleme yapılır.
Bu şekilde, iki butonu kullanarak hızı artıran ve düşüren bir pulse jeneratörü oluşturabilirsiniz. Pulse genişliğini (hızı) artırmak veya azaltmak için butonları kullanabilirsiniz.
Tabii, Arduino kullanarak üç adet butonla yön değiştirmek ve hızı artırmak/azaltmak için bir pulse jeneratörü yapabiliriz. İşte örnek bir Arduino kodu:
-----------------------------------------------------------------------
// 3 adet butonla yön değiştiren ve hızı artıran/azaltan pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int directionButtonPin = 2; // Yön değiştiren buton için Arduino pin numarası
const int increaseButtonPin = 3; // Hızı artıran buton için Arduino pin numarası
const int decreaseButtonPin = 4; // Hızı düşüren buton için Arduino pin numarası
bool isForward = true; // İleri yön kontrolü
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
int increment = 100; // Hız artış miktarı
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(directionButtonPin, INPUT_PULLUP); // Yön değiştiren butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(increaseButtonPin, INPUT_PULLUP); // Hızı artıran butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(decreaseButtonPin, INPUT_PULLUP); // Hızı düşüren butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Yön değiştiren butonun durumunu oku
if (digitalRead(directionButtonPin) == LOW) {
isForward = !isForward; // Yönü tersine çevir
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Hızı artıran butonun durumunu oku
if (digitalRead(increaseButtonPin) == LOW) {
pulseWidth += increment; // Pulse genişliğini artır
}
// Hızı düşüren butonun durumunu oku
if (digitalRead(decreaseButtonPin) == LOW) {
pulseWidth -= increment; // Pulse genişliğini azalt
}
// Pulse genişliğini sınırla (minimum 0, maksimum 1000 aralığında tut)
if (pulseWidth < 0) {
pulseWidth = 0;
}
if (pulseWidth > 1000) {
pulseWidth = 1000;
}
// İleri veya geri yönde pulse jeneratörünü çalıştır
if (isForward) {
forwardPulse();
} else {
reversePulse();
}
}
// İleri yönde pulse jeneratörü
void forwardPulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin
, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
// Geri yönde pulse jeneratörü
void reversePulse() {
digitalWrite(outputPin, LOW); // Pulse başlangıcında çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, HIGH); // Pulse sonunda çıkış pinini yüksek yap
delay(1000); // Pulse arasında 1 saniye bekle
}
```
Yukarıdaki kodda, 3 adet buton kullanarak yön değiştiren ve hızı artıran/azaltan bir pulse jeneratörü oluşturulur. `directionButtonPin`, yön değiştiren buton olarak tanımlanırken, `increaseButtonPin` ve `decreaseButtonPin` hızı artıran ve azaltan butonlar olarak tanımlanır. Butonlar Arduino'nun dijital pinlerine bağlanır ve dahili pull-up direnci etkinleştirilir.
`loop()` fonksiyonunda, her bir butonun durumu kontrol edilir. Yön değiştiren butona basılırsa, yön değiştirilir. Hızı artıran butona basılırsa, pulse genişliği (hız) artırılır. Hızı düşüren butona basılırsa, pulse genişliği (hız) azaltılır.
Pulse genişliği belirli aralıklarla sınırlanır. Bu örnekte, pulse genişliği 0 ile 1000 arasında tutulur.
Daha sonra, `forwardPulse()` ve `reversePulse()` fonksiyonları kullanılarak ileri veya geri yönde pulse jeneratörü çalıştırılır. İleri yönde pulse jeneratörü çalıştığında çıkış pini yüksek (HIGH) olacakken, geri yönde pulse jeneratörü çalıştığında çıkış pini düşük (LOW) olacaktır.
Bu şekilde, üç adet buton kullanarak yön değiştiren ve hızı artıran/azaltan bir pulse jeneratörü oluşturabilirsiniz.
Aşağıda, Arduino kullanarak 4 adet butonla saat yönünde ve saat yönünün tersine dönen bir pulse jeneratörü oluşturmanızı sağlayan bir örnek kod bulunmaktadır:
-----------------------------------------------------------------------
// 4 adet butonla saat yönünde ve saat yönünün tersine dönen hızlı pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int clockwiseButtonPin = 2; // Saat yönü butonu için Arduino pin numarası
const int counterclockwiseButtonPin = 3; // Saat yönünün tersi butonu için Arduino pin numarası
const int increaseButtonPin = 4; // Hızı artıran buton için Arduino pin numarası
const int decreaseButtonPin = 5; // Hızı düşüren buton için Arduino pin numarası
bool isClockwise = true; // Saat yönü kontrolü
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
int increment = 100; // Hız artış miktarı
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(clockwiseButtonPin, INPUT_PULLUP); // Saat yönü butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(counterclockwiseButtonPin, INPUT_PULLUP); // Saat yönünün tersi butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(increaseButtonPin, INPUT_PULLUP); // Hızı artıran butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(decreaseButtonPin, INPUT_PULLUP); // Hızı düşüren butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Saat yönü butonunun durumunu oku
if (digitalRead(clockwiseButtonPin) == LOW) {
isClockwise = true; // Saat yönüne ayarla
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Saat yönünün tersi butonunun durumunu oku
if (digitalRead(counterclockwiseButtonPin) == LOW) {
isClockwise = false; // Saat yönünün tersine ayarla
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Hızı artıran butonun durumunu oku
if (digitalRead(increaseButtonPin) == LOW) {
pulseWidth += increment; // Pulse genişliğini artır
}
// Hızı düşüren butonun durumunu oku
if (digitalRead(decreaseButtonPin) == LOW) {
pulseWidth -= increment; // Pulse genişliğini azalt
}
// Pulse genişliğini sınırla (minimum 0, maksimum 1000 aralığında tut)
if (pulseWidth < 0) {
pulseWidth = 0;
}
if (pulseWidth > 1000) {
pulseWidth = 1000;
}
// Pulse jeneratörünü çalıştır
if (isClockwise) {
forwardPulse();
} else {
reversePulse();
}
}
// Saat yönünde pulse jeneratörü
void forwardPulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
// Saat yönünün tersine pulse jeneratörü
void reversePulse() {
digitalWrite(outputPin, LOW); // Pulse başlangıcında çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, HIGH); // Pulse sonunda çıkış pinini yüksek yap
delay(1000); // Pulse arasında 1 saniye bekle
}
```
Yukarıdaki kodda, 4 adet buton kullanarak saat yönünde ve saat yönünün tersine dönen bir pulse jeneratörü oluşturulur. `clockwiseButtonPin`, saat yönü butonu olarak tanımlanırken, `counterclockwiseButtonPin` saat yönünün tersi butonu olarak tanımlanır. `increaseButtonPin` ve `decreaseButtonPin` hızı artıran ve azaltan butonlar olarak tanımlanır. Butonlar Arduino'nun dijital pinlerine bağlanır ve dahili pull-up direnci etkinleştirilir.
`loop()` fonksiyonunda, her bir butonun durumu kontrol edilir. Saat yönü butonuna basılırsa, saat yönü ayarlanır. Saat yönünün tersi butonuna basılırsa, saat yönü tersine ayarlanır. Hızı artıran butona basılırsa, pulse genişliği (hız) artırılır. Hızı düşüren butona basılırsa, pulse genişliği (hız) azaltılır.
Pulse genişliği belirli aralıklarla sınırlanır. Bu örnekte, pulse genişliği 0 ile 1000 arasında tutulur.
Daha sonra, `forwardPulse()` ve `reversePulse()` fonksiyonları kullanılarak saat yönünde veya saat yönünün tersine pulse jeneratörü çalıştırılır. Saat yönünde pulse jeneratörü çalıştığında çıkış pini yüksek (HIGH) olacakken, saat yönünün tersine pulse jeneratörü çalıştığında çıkış pini düşük (LOW) olacaktır.
Bu şekilde, dört adet buton kullanarak saat yönünde ve saat yönünün tersine dö
nen bir pulse jeneratörü oluşturabilirsiniz.
Aşağıda, Arduino kullanarak iki adet buton ve bir potansiyometre ile yön ve hızın ayarlanabileceği bir pulse jeneratörü yapımını gösteren bir örnek kod bulunmaktadır:
-----------------------------------------------------------------------
// İki adet buton ve potansiyometre ile yön ve hız ayarlanabilir pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int directionButtonPin = 2; // Yön değiştirme butonu için Arduino pin numarası
const int speedButtonPin = 3; // Hız değiştirme butonu için Arduino pin numarası
const int potentiometerPin = A0; // Potansiyometre bağlı olan Arduino pin numarası
bool isClockwise = true; // Saat yönü kontrolü
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
int increment = 100; // Hız artış miktarı
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(directionButtonPin, INPUT_PULLUP); // Yön değiştirme butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(speedButtonPin, INPUT_PULLUP); // Hız değiştirme butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Yön değiştirme butonunun durumunu oku
if (digitalRead(directionButtonPin) == LOW) {
isClockwise = !isClockwise; // Yönü değiştir
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Hız değiştirme butonunun durumunu oku
if (digitalRead(speedButtonPin) == LOW) {
pulseWidth += increment; // Pulse genişliğini artır
}
// Potansiyometre değerini oku ve pulse genişliğini ayarla
int potValue = analogRead(potentiometerPin);
pulseWidth = map(potValue, 0, 1023, 100, 1000); // Potansiyometre değerini 100-1000 aralığına dönüştür
// Pulse jeneratörünü çalıştır
if (isClockwise) {
forwardPulse();
} else {
reversePulse();
}
}
// Saat yönünde pulse jeneratörü
void forwardPulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
// Saat yönünün tersine pulse jeneratörü
void reversePulse() {
digitalWrite(outputPin, LOW); // Pulse başlangıcında çıkış pin
ini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, HIGH); // Pulse sonunda çıkış pinini yüksek yap
delay(1000); // Pulse arasında 1 saniye bekle
}
```
Yukarıdaki kodda, iki adet buton ve bir potansiyometre kullanılarak yön ve hızın ayarlanabileceği bir pulse jeneratörü oluşturulur. `directionButtonPin`, yön değiştirme butonu olarak tanımlanırken, `speedButtonPin` hız değiştirme butonu olarak tanımlanır. Potansiyometre, `potentiometerPin` ile bağlıdır ve pulse genişliği (hız) ayarlamak için kullanılır. Butonlar Arduino'nun dijital pinlerine bağlanır ve dahili pull-up direnci etkinleştirilir.
`loop()` fonksiyonunda, yön değiştirme butonu durumu kontrol edilir. Eğer butona basılırsa, yön değiştirilir. Hız değiştirme butonu durumu kontrol edilir ve pulse genişliği (hız) artırılır. Potansiyometre değeri okunarak pulse genişliği (hız) ayarlanır.
Pulse genişliği belirli aralıklarla sınırlanır. Bu örnekte, pulse genişliği 100 ila 1000 arasında tutulur.
Daha sonra, `forwardPulse()` ve `reversePulse()` fonksiyonları kullanılarak saat yönünde veya saat yönünün tersine pulse jeneratörü çalıştırılır. Saat yönünde pulse jeneratörü çalıştığında çıkış pini yüksek (HIGH) olacakken, saat yönünün tersine pulse jeneratörü çalıştığında çıkış pini düşük (LOW) olacaktır.
Bu şekilde, iki adet buton ve bir potansiyometre kullanarak yön ve hızın ayarlanabileceği bir pulse jeneratörü oluşturabilirsiniz.
Anladığım kadarıyla, belirli bir turda saat yönünde ve belirli bir turda saat yönünün tersinde bir butona basıldığında referans sensörüne giden bir pulse jeneratörü yapmak istiyorsunuz. İşte bu özelliği içeren bir Arduino kodu örneği:
-----------------------------------------------------------------------
// Referans sensörüne giden pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int referenceButtonPin = 2; // Referans butonu için Arduino pin numarası
int pulseCount = 0; // Pulse sayısı
bool isClockwise = true; // Saat yönü kontrolü
int pulseWidth = 500; // Pulse genişliği (milisaniye cinsinden)
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(referenceButtonPin, INPUT_PULLUP); // Referans butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Referans butonunun durumunu oku
if (digitalRead(referenceButtonPin) == LOW) {
pulseCount = 0; // Pulse sayısını sıfırla
isClockwise = !isClockwise; // Yönü değiştir
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Pulse jeneratörünü çalıştır
if (isClockwise) {
forwardPulse();
} else {
reversePulse();
}
}
// Saat yönünde pulse jeneratörü
void forwardPulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(100); // Pulse arasında kısa bir bekleme yap
pulseCount++; // Pulse sayısını artır
// Belirli tur sayısında referans sensörüne pulse gönder
if (pulseCount == 360) { // 360 pulse bir turu temsil ediyor
sendReferencePulse();
pulseCount = 0; // Pulse sayısını sıfırla
}
}
// Saat yönünün tersinde pulse jeneratörü
void reversePulse() {
digitalWrite(outputPin, LOW); // Pulse başlangıcında çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, HIGH); // Pulse sonunda çıkış pinini yüksek yap
delay(100); // Pulse arasında kısa bir bekleme yap
pulseCount--; // Pulse sayısını azalt
// Belirli tur sayısında referans sensörüne pulse gönder
if (pulseCount == -360) { // -360 pulse bir turu temsil ediyor
sendReferencePulse();
pulseCount = 0; // Pulse sayısını sıfırla
}
}
// Referans sensörüne pulse gönderen fonksiyon
void sendReferencePulse() {
// Burada referans sensörüne pulse gönderme işlemlerini gerçekleştirin
// Örneğin, bir başka pini yüksek yaparak referans pulse'unu gönderebilirsiniz
}
```
Yukarıdaki kodda, belirli bir turda saat yönünde ve belirli bir turda saat yönünün tersinde bir butona basıldığında referans sensörüne giden bir pulse jeneratörü oluşturulur. `outputPin` belirli bir turda pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `referenceButtonPin` ise referans butonunun bağlı olduğu Arduino pin numarasını temsil eder.
`forwardPulse()` fonksiyonu, saat yönünde pulse jeneratörünü çalıştırırken `reversePulse()` fonksiyonu saat yönünün tersinde pulse jeneratörünü çalıştırır. Bu fonksiyonlar pulse genişliği `pulseWidth` kadar bekleyerek ve ardından pulse sayısını kontrol ederek pulse jeneratörünü kontrol eder. Belirli bir tur sayısında (`pulseCount`), `sendReferencePulse()` fonksiyonu çağrılarak referans sensörüne pulse gönderilir. Bu kısmı sizin referans sensörüyle uyumlu şekilde düzenlemeniz gerekmektedir.
Bu şekilde, belirli bir turda saat yönünde ve belirli bir turda saat yönünün tersinde bir butona basıldığında referans sensörüne giden bir pulse jeneratörü oluşturabilirsiniz. Referans sensörüne pulse gönderme kısmını kendi projenizin gereksinimlerine göre uyarlayarak kullanabilirsiniz.
Aşağıda, Arduino kullanarak iki adet potansiyometre ile hız ve ivme kontrolü yapılabilen, iki adet buton ile yön kontrolü yapılan bir pulse jeneratörü örneği bulunmaktadır:
-----------------------------------------------------------------------
// İki adet potansiyometre ve iki adet buton ile hız, ivme ve yön kontrollü pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int directionButtonPin = 2; // Yön değiştirme butonu için Arduino pin numarası
const int speedButtonPin = 3; // Hız değiştirme butonu için Arduino pin numarası
const int speedPotentiometerPin = A0; // Hızı ayarlayan potansiyometre bağlı olan Arduino pin numarası
const int accelerationPotentiometerPin = A1; // Ivme ayarlayan potansiyometre bağlı olan Arduino pin numarası
bool isClockwise = true; // Saat yönü kontrolü
int pulseWidth = 500; // Pulse genişliği (hız) (milisaniye cinsinden)
int acceleration = 1; // Ivme
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(directionButtonPin, INPUT_PULLUP); // Yön değiştirme butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(speedButtonPin, INPUT_PULLUP); // Hız değiştirme butonunu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Yön değiştirme butonunun durumunu oku
if (digitalRead(directionButtonPin) == LOW) {
isClockwise = !isClockwise; // Yönü değiştir
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Hız değiştirme butonunun durumunu oku
if (digitalRead(speedButtonPin) == LOW) {
pulseWidth -= acceleration * 10; // Hızı azalt
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Potansiyometre değerlerini oku ve hız, ivme değerlerini ayarla
int speedPotValue = analogRead(speedPotentiometerPin);
pulseWidth = map(speedPotValue, 0, 1023, 100, 1000); // Potansiyometre değerini 100-1000 aralığına dönüştür
int accelerationPotValue = analogRead(accelerationPotentiometerPin);
acceleration = map(accelerationPotValue, 0, 1023, 1, 10); // Potansiyometre değerini 1-10 aralığına dönüştür
// Pulse jeneratörünü çalıştır
if (isClockwise) {
forwardPulse();
} else {
reversePulse();
}
}
// Saat y
önünde pulse jeneratörü
void forwardPulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
}
// Saat yönünün tersinde pulse jeneratörü
void reversePulse() {
digitalWrite(outputPin, LOW); // Pulse başlangıcında çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, HIGH); // Pulse sonunda çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
}
```
Yukarıdaki kodda, iki adet potansiyometre ve iki adet buton kullanarak hız, ivme ve yön kontrolü yapılan bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `directionButtonPin` yön değiştirme butonu, `speedButtonPin` hız değiştirme butonu, `speedPotentiometerPin` hızı ayarlayan potansiyometre ve `accelerationPotentiometerPin` ivmeyi ayarlayan potansiyometre için Arduino pin numaralarını temsil eder.
`forwardPulse()` fonksiyonu saat yönünde pulse jeneratörünü çalıştırırken, `reversePulse()` fonksiyonu saat yönünün tersinde pulse jeneratörünü çalıştırır. Bu fonksiyonlar pulse genişliği `pulseWidth` kadar bekleme süresi ekleyerek pulse jeneratörünü kontrol eder. Hız ve ivme değerleri, potansiyometrelerin okunan değerlerine göre ayarlanır.
Pulse genişliği (hız), potansiyometrenin okunan değerine göre 100 ila 1000 arasında sınırlanır. Ivme, potansiyometrenin okunan değerine göre 1 ila 10 arasında sınırlanır.
Bu şekilde, iki adet potansiyometre ile hız ve ivme kontrolü yapılabilen, iki adet buton ile yön kontrolü yapılan bir pulse jeneratörü oluşturabilirsiniz.
Tabii, aşağıda iki buton ile ileri ve geri hareket sürelerini uzatan veya kısaltan bir pulse jeneratörü örneği bulunmaktadır:
-----------------------------------------------------------------------
// İki buton ile ileri ve geri hareket sürelerini uzatan veya kısaltan pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int increaseButtonPin = 2; // Süreyi artıran buton için Arduino pin numarası
const int decreaseButtonPin = 3; // Süreyi azaltan buton için Arduino pin numarası
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
int increment = 100; // Süre artış miktarı
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(increaseButtonPin, INPUT_PULLUP); // Süreyi artıran butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(decreaseButtonPin, INPUT_PULLUP); // Süreyi azaltan butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Süreyi artıran butonun durumunu oku
if (digitalRead(increaseButtonPin) == LOW) {
pulseWidth += increment; // Pulse genişliğini artır
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Süreyi azaltan butonun durumunu oku
if (digitalRead(decreaseButtonPin) == LOW) {
pulseWidth -= increment; // Pulse genişliğini azalt
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Pulse genişliğini sınırla (minimum 0, maksimum 1000 aralığında tut)
if (pulseWidth < 0) {
pulseWidth = 0;
}
if (pulseWidth > 1000) {
pulseWidth = 1000;
}
// Pulse jeneratörünü çalıştır
forwardPulse();
reversePulse();
}
// İleri yönde pulse jeneratörü
void forwardPulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(1000); // Pulse arasında 1 saniye bekle
}
// Geri yönde pulse jeneratörü
void reversePulse() {
digitalWrite(outputPin, LOW); // Pulse başlangıcında çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, HIGH); // Pulse sonunda çıkış pinini yüksek yap
delay(1000); // Pulse arasında 1
saniye bekle
}
```
Yukarıdaki kodda, iki buton kullanarak ileri ve geri hareket sürelerini uzatan veya kısaltan bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `increaseButtonPin` süreyi artıran buton, `decreaseButtonPin` süreyi azaltan buton için Arduino pin numaralarını temsil eder.
`loop()` fonksiyonunda, süreyi artıran butonun durumu kontrol edilir. Eğer butona basılırsa, pulse genişliği (süre) artırılır. Süreyi azaltan butonun durumu kontrol edilir ve pulse genişliği (süre) azaltılır.
Pulse genişliği belirli aralıklarla sınırlanır. Bu örnekte, pulse genişliği 0 ile 1000 arasında tutulur.
Daha sonra, `forwardPulse()` ve `reversePulse()` fonksiyonları kullanılarak ileri ve geri hareket süreleri ayarlanarak pulse jeneratörü çalıştırılır. İleri yönde pulse jeneratörü çalıştığında çıkış pini yüksek (HIGH) olacakken, geri yönde pulse jeneratörü çalıştığında çıkış pini düşük (LOW) olacaktır.
Bu şekilde, iki buton ile ileri ve geri hareket sürelerini uzatan veya kısaltan bir pulse jeneratörü oluşturabilirsiniz.
Aşağıda üç buton kullanarak tur mesafesini ayarlayan ve bir butona basıldığında referans sinyali gönderen bir pulse jeneratörü örneği bulunmaktadır:
-----------------------------------------------------------------------
// 3 buton ile tur mesafesini ayarlayan ve tuşa basıldığında referans gönderen pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int distanceButtonPin = 2; // Tur mesafesi ayarlayan buton için Arduino pin numarası
const int referenceButtonPin = 3; // Referans gönderen buton için Arduino pin numarası
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
int distance = 360; // Tur mesafesi (pulse sayısı)
bool sendReference = false; // Referans gönderme kontrolü
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(distanceButtonPin, INPUT_PULLUP); // Tur mesafesi ayarlayan butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(referenceButtonPin, INPUT_PULLUP); // Referans gönderen butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Tur mesafesi ayarlayan butonun durumunu oku
if (digitalRead(distanceButtonPin) == LOW) {
setDistance(); // Tur mesafesini ayarla
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Referans gönderen butonun durumunu oku
if (digitalRead(referenceButtonPin) == LOW) {
sendReference = true; // Referans gönderme kontrolünü etkinleştir
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Pulse jeneratörünü çalıştır
generatePulses();
}
// Tur mesafesini ayarlayan fonksiyon
void setDistance() {
// Burada tur mesafesini ayarlamak için gerekli işlemleri gerçekleştirin
// Örneğin, başka bir buton yardımıyla tur mesafesini artırabilir veya azaltabilirsiniz
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulses() {
for (int i = 0; i < distance; i++) {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
// Referans gönderme kontrolünü kontrol et
if (sendReference) {
sendReferencePulse(); // Referans pulse'unu gönder
sendReference = false; // Referans gönderme kontrolünü sıfırla
}
}
}
// Referans pulse'unu gönderen fonksiyon
void sendReferencePulse() {
// Burada referans pulse'unu göndermek için gerekli işlemleri gerçekleştirin
// Örneğin, başka bir pini yüksek yaparak referans pulse'unu gönderebilirsiniz
}
```
Yukarıdaki kodda, üç buton kullanarak tur mesafesini ayarlayan ve bir butona basıldığında referans sinyali gönderen bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `distanceButtonPin` tur mesafesini ayarlayan buton, `referenceButtonPin` referans gönderen buton için Arduino pin numaralarını temsil eder.
`setDistance()` fonksiyonu tur mesafesini ayarlamak için kullanılır. Bu fonksiyonu, belirli bir tur mesafesini artırmak veya azaltmak için başka bir buton ile uyarlayabilirsiniz.
`generatePulses()` fonksiyonu, pulse jeneratörünü çalıştırır. Belirtilen tur mesafesine (`distance`) kadar pulse oluşturur. Referans gönderme kontrolü aktif hale geldiğinde (`sendReference == true`), `sendReferencePulse()` fonksiyonu çağrılarak referans pulse'u gönderilir.
`sendReferencePulse()` fonksiyonunda, referans pulse'unu göndermek için gerekli işlemleri gerçekleştirin. Bu kısmı kendi projenizin gereksinimlerine göre uyarlayabilirsiniz.
Bu şekilde, üç buton ile tur mesafesini ayarlayan ve bir butona basıldığında referans sinyali gönderen bir pulse jeneratörü oluşturabilirsiniz.
Pulse jeneratör nedir
Pulse jeneratörü, belirli bir süre boyunca tekrarlanan darbe sinyalleri üreten elektronik bir devredir. Pulse jeneratörleri, genellikle dijital elektronik projelerinde kullanılan temel bir bileşendir. Darbe genişliği, frekansı ve diğer parametreleri kontrol edilebilir ve bu sayede çeşitli uygulamalarda kullanılabilir.
Pulse jeneratörleri, darbeleri üretmek için çeşitli yöntemler kullanabilir. Bu yöntemler arasında astabil multivibratorler, monostabil multivibratorler, timer entegre devreler ve mikrodenetleyiciler gibi elektronik bileşenler yer alır. Pulse jeneratörleri, genellikle darbe genişlik modülasyonu (PWM) ve zamanlama işlemleri için kullanılır.
Pulse jeneratörleri, birçok alanda yaygın olarak kullanılır. Örneğin, elektronik müzik aletlerinde ses üretmek, motor hız kontrolü, servo motor kontrolü, röle sürme, sinyal modülasyonu, iletişim sistemleri ve otomasyon uygulamaları gibi birçok alanda pulse jeneratörleri kullanılır.
Pulse jeneratörleri, genellikle belirli bir frekansa veya darbe genişliğine sahip sinyalleri üretir. Bu sinyaller, belirli bir periyot içinde düzenli aralıklarla tekrarlanır. Darbe genişliği, darbelerin açık (yüksek) durumda kalma süresini kontrol ederken, frekans ise darbelerin tekrarlanma hızını belirler.
Özet olarak, pulse jeneratörleri, belirli bir süre boyunca tekrarlanan darbe sinyalleri üreten elektronik devrelerdir ve birçok uygulamada sinyal üretimi ve kontrolü için kullanılır.
4 button kullanarak Arduino ile pulse jeneratör yapmak görevleri sen belirle örnekte
Tabii, dört adet buton kullanarak Arduino ile bir pulse jeneratörü yapabiliriz. İşte bir örnek:
-----------------------------------------------------------------------
// 4 butonlu pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int startButtonPin = 2; // Pulse jeneratörünü başlatan buton için Arduino pin numarası
const int stopButtonPin = 3; // Pulse jeneratörünü durduran buton için Arduino pin numarası
const int increaseSpeedButtonPin = 4; // Hızı artıran buton için Arduino pin numarası
const int decreaseSpeedButtonPin = 5; // Hızı azaltan buton için Arduino pin numarası
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
bool isRunning = false; // Pulse jeneratörünün çalışma durumu
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(startButtonPin, INPUT_PULLUP); // Pulse jeneratörünü başlatan butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(stopButtonPin, INPUT_PULLUP); // Pulse jeneratörünü durduran butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(increaseSpeedButtonPin, INPUT_PULLUP); // Hızı artıran butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(decreaseSpeedButtonPin, INPUT_PULLUP); // Hızı azaltan butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Pulse jeneratörünü başlatan butonun durumunu oku
if (digitalRead(startButtonPin) == LOW) {
startGenerator(); // Pulse jeneratörünü başlat
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Pulse jeneratörünü durduran butonun durumunu oku
if (digitalRead(stopButtonPin) == LOW) {
stopGenerator(); // Pulse jeneratörünü durdur
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Hızı artıran butonun durumunu oku
if (digitalRead(increaseSpeedButtonPin) == LOW) {
increaseSpeed(); // Hızı artır
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Hızı azaltan butonun durumunu oku
if (digitalRead(decreaseSpeedButtonPin) == LOW) {
decreaseSpeed(); // Hızı azalt
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Pulse jeneratör
ünü çalıştır
if (isRunning) {
generatePulse();
}
}
// Pulse jeneratörünü başlatan fonksiyon
void startGenerator() {
isRunning = true; // Pulse jeneratörünün çalışma durumunu etkinleştir
}
// Pulse jeneratörünü durduran fonksiyon
void stopGenerator() {
isRunning = false; // Pulse jeneratörünün çalışma durumunu devre dışı bırak
digitalWrite(outputPin, LOW); // Pulse çıkışını düşük yap
}
// Hızı artıran fonksiyon
void increaseSpeed() {
pulseWidth += 100; // Pulse genişliğini artır
}
// Hızı azaltan fonksiyon
void decreaseSpeed() {
pulseWidth -= 100; // Pulse genişliğini azalt
if (pulseWidth < 100) {
pulseWidth = 100;
}
}
// Pulse jeneratörü
void generatePulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
}
```
Yukarıdaki kodda, dört adet buton kullanarak bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `startButtonPin` pulse jeneratörünü başlatan buton, `stopButtonPin` pulse jeneratörünü durduran buton, `increaseSpeedButtonPin` hızı artıran buton ve `decreaseSpeedButtonPin` hızı azaltan buton için Arduino pin numaralarını temsil eder.
`startGenerator()` fonksiyonu pulse jeneratörünü başlatır, `stopGenerator()` fonksiyonu pulse jeneratörünü durdurur. `increaseSpeed()` fonksiyonu hızı artırırken, `decreaseSpeed()` fonksiyonu hızı azaltır. Hız artışı ve azalışı her seferinde 100 birim olur.
`generatePulse()` fonksiyonu, pulse jeneratörünü çalıştırır. Pulse başlangıcında çıkış pini yüksek (HIGH) yapılır, ardından pulse genişliği kadar beklenir ve pulse sonunda çıkış pini düşük (LOW) yapılır.
Bu şekilde, dört buton kullanarak pulse jeneratörünü başlatma, durdurma, hızını artırma ve azaltma işlemlerini gerçekleştirebilirsiniz.
8 buton lu pulse jeneratör Arduino ile görevleri sen ata
Tabii, işte sekiz adet buton kullanarak Arduino ile pulse jeneratörü yapabilmeniz için bir örnek:
-----------------------------------------------------------------------
// 8 butonlu pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int buttonPins[] = {2, 3, 4, 5, 6, 7, 8, 10}; // Butonların Arduino pin numaraları
int pulseWidth = 500; // Başlangıçta ayarlanacak pulse genişliği (milisaniye cinsinden)
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
for (int i = 0; i < sizeof(buttonPins) / sizeof(buttonPins[0]); i++) {
pinMode(buttonPins[i], INPUT_PULLUP); // Butonları giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
}
void loop() {
// Butonların durumunu oku
for (int i = 0; i < sizeof(buttonPins) / sizeof(buttonPins[0]); i++) {
if (digitalRead(buttonPins[i]) == LOW) {
performButtonAction(i); // Buton görevini gerçekleştir
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
}
// Pulse jeneratörünü çalıştır
generatePulse();
}
// Buton görevlerini gerçekleştiren fonksiyon
void performButtonAction(int buttonIndex) {
switch (buttonIndex) {
case 0:
startGenerator(); // Pulse jeneratörünü başlat
break;
case 1:
stopGenerator(); // Pulse jeneratörünü durdur
break;
case 2:
increaseSpeed(); // Hızı artır
break;
case 3:
decreaseSpeed(); // Hızı azalt
break;
case 4:
// İstenilen bir görev
break;
case 5:
// İstenilen bir görev
break;
case 6:
// İstenilen bir görev
break;
case 7:
// İstenilen bir görev
break;
}
}
// Pulse jeneratörünü başlatan fonksiyon
void startGenerator() {
digitalWrite(outputPin, HIGH); // Pulse çıkışını yüksek yap
}
// Pulse jeneratörünü durduran fonksiyon
void stopGenerator() {
digitalWrite(outputPin, LOW); // Pulse çıkışını düşük yap
}
// Hızı artıran fonksiyon
void increaseSpeed() {
pulseWidth += 100; // Pulse genişliğini artır
}
// Hızı azaltan fonksiyon
void decreaseSpeed() {
pulseWidth -= 100; // Pulse genişliğini azalt
if (pulseWidth < 100) {
pulseWidth = 100;
}
}
// Pulse jeneratörü
void generatePulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delayMicro
seconds(pulseWidth); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delayMicroseconds(pulseWidth); // Pulse genişliği kadar bekle
}
```
Yukarıdaki kodda, sekiz adet buton kullanarak bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `buttonPins` dizisi, sekiz butonun Arduino pin numaralarını içerir.
Butonların durumunu `loop()` fonksiyonunda kontrol ediyoruz. Eğer bir butona basıldıysa, `performButtonAction()` fonksiyonunu çağırarak ilgili buton görevini gerçekleştiririz. Bu örnekte, ilk buton pulse jeneratörünü başlatırken, ikinci buton pulse jeneratörünü durdurur, üçüncü buton hızı artırır ve dördüncü buton hızı azaltır. İstenilen görevleri gerçekleştirmek için diğer butonlara da gerekli işlemleri ekleyebilirsiniz.
`startGenerator()` fonksiyonu pulse jeneratörünü başlatırken, `stopGenerator()` fonksiyonu pulse jeneratörünü durdurur. `increaseSpeed()` fonksiyonu hızı artırırken, `decreaseSpeed()` fonksiyonu hızı azaltır. Hız artışı ve azalışı her seferinde 100 birim olur.
`generatePulse()` fonksiyonu, pulse jeneratörünü çalıştırır. Pulse başlangıcında çıkış pini yüksek (HIGH) yapılır, ardından pulse genişliği kadar beklenir ve pulse sonunda çıkış pini düşük (LOW) yapılır.
Bu şekilde, sekiz buton kullanarak pulse jeneratörünü başlatma, durdurma, hızını artırma, hızını azaltma ve diğer istenilen görevleri gerçekleştirebilirsiniz.Tuşa basıldığında 10 tur ileri 10 tur geri yapan sonra tuşa basılmasını bekleyen pulse jeneratörü kod örneği arduni ile
Tabii, işte bir örnek Arduino kodu, bir tuşa basıldığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörü oluşturan ve ardından bir sonraki tuşa basılmasını bekleyen:
-----------------------------------------------------------------------
// 10 tur ileri ve geri hareket eden pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int buttonPin = 2; // Tuşun Arduino pin numarası
const int pulseDelay = 500; // Pulse arasındaki bekleme süresi (milisaniye cinsinden)
const int numPulses = 10; // Toplam pulse sayısı
bool forwardMotion = true; // İleri hareket kontrolü
int pulseCount = 0; // Pulse sayacı
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(buttonPin, INPUT_PULLUP); // Tuşu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Tuşun durumunu oku
if (digitalRead(buttonPin) == LOW) {
// Tuşa basıldığında pulse jeneratörünü çalıştır
runPulseGenerator();
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void runPulseGenerator() {
// İleri veya geri hareketi belirle
if (forwardMotion) {
generatePulses(numPulses); // İleri hareket için pulse jeneratörünü çalıştır
} else {
generatePulses(-numPulses); // Geri hareket için pulse jeneratörünü çalıştır
}
// İleri veya geri hareketi değiştir
forwardMotion = !forwardMotion;
// Bir sonraki tuşa basılmasını bekle
while (digitalRead(buttonPin) == HIGH) {
// Bekle
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulses(int count) {
for (int i = 0; i < abs(count); i++) {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delay(pulseDelay); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(pulseDelay); // Pulse genişliği kadar bekle
}
}
```
Yukarıdaki kodda, bir tuşa basıldığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `buttonPin`, tuşun Arduino pin numarasını temsil eder.
`runPulseGenerator()` fonksiyonu, tuşa basıldığında pulse jeneratörünü çalıştırır. İleri veya geri hareketi bel
irler, pulse jeneratörünü çalıştırır ve ardından ileri veya geri hareketi değiştirir. Daha sonra, bir sonraki tuşa basılmasını beklemek için döngüye girer.
`generatePulses()` fonksiyonu, belirli bir sayıda pulse oluşturur. İleri hareket için pozitif sayı, geri hareket için negatif sayı kullanılır. Pulse oluşturma işlemi belirli bir bekleme süresi (`pulseDelay`) ve pulse sayısı (`count`) ile gerçekleştirilir.
Bu şekilde, bir tuşa basıldığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörü oluşturabilir ve bir sonraki tuşa basılmasını bekleyebilirsiniz.
Sırada sensörü görene kadar ileri ve diğer sensörü görene kadar geri hareket eden iki sensör arasında sonsuz çalışan pulse jeneratör kodu var
Tabii, işte iki adet sensör arasında sonsuz çalışan pulse jeneratörü yapabilmeniz için bir örnek Arduino kodu:
-----------------------------------------------------------------------
// İki sensör arasında sonsuz çalışan pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int forwardSensorPin = 2; // İleri hareket sensörünün Arduino pin numarası
const int backwardSensorPin = 3; // Geri hareket sensörünün Arduino pin numarası
const int pulseDelay = 500; // Pulse arasındaki bekleme süresi (milisaniye cinsinden)
bool forwardMotion = true; // İleri hareket kontrolü
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(forwardSensorPin, INPUT); // İleri hareket sensörünü giriş moduna ayarla
pinMode(backwardSensorPin, INPUT); // Geri hareket sensörünü giriş moduna ayarla
}
void loop() {
// İleri hareket sensörünün durumunu oku
bool forwardSensor = digitalRead(forwardSensorPin);
// Geri hareket sensörünün durumunu oku
bool backwardSensor = digitalRead(backwardSensorPin);
// İleri hareket sensörü algıladığında veya geri hareket sensörü algılamadığında pulse jeneratörünü çalıştır
if (forwardSensor || !backwardSensor) {
runPulseGenerator();
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void runPulseGenerator() {
// İleri hareket kontrolüne göre pulse jeneratörünü çalıştır
if (forwardMotion) {
generatePulse(true); // İleri hareket için pulse jeneratörünü çalıştır
} else {
generatePulse(false); // Geri hareket için pulse jeneratörünü çalıştır
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulse(bool forward) {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delay(pulseDelay); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(pulseDelay); // Pulse genişliği kadar bekle
// İleri hareket kontrolünü güncelle
forwardMotion = forward;
}
```
Yukarıdaki kodda, iki adet sensör arasında sonsuz çalışan pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `forwardSensorPin` ileri hareket sensörünün Arduino pin numarasını, `backwardSensorPin` geri hareket sensörünün Arduino pin numarasını temsil eder.
`loop()` fonksiyonunda, ileri hareket sensörünün durumu (`forwardSensor`) ve geri hareket sensörünün durumu (`backwardSensor`) okunur. Eğer ileri hareket sensörü algılandığında veya geri hare
ket sensörü algılanmadığında, pulse jeneratörü çalıştırılır.
`runPulseGenerator()` fonksiyonu, pulse jeneratörünü çalıştırır. `generatePulse()` fonksiyonu ise pulse jeneratörünü belirli bir yönde çalıştırır. İleri hareket kontrolüne göre, pulse jeneratörü ileri veya geri hareket eder.
`generatePulse()` fonksiyonunda, pulse oluşturma işlemi belirli bir bekleme süresi (`pulseDelay`) ve pulse çıkışı için ilgili pinin durumunu değiştirerek gerçekleştirilir. Ardından, ileri hareket kontrolü güncellenir.
Bu şekilde, iki sensör arasında sonsuz çalışan pulse jeneratörü oluşturabilirsiniz. İleri hareket sensörü algılandığında veya geri hareket sensörü algılanmadığında pulse jeneratörü çalışır.
Yukarıdaki örneğimize bir start buton birde stop buton ekleyelim
Tabii, işte güncellenmiş Arduino kodu, bir start butonu ve bir stop butonu eklenmiş şekilde:
-----------------------------------------------------------------------
// İki sensör arasında sonsuz çalışan pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int forwardSensorPin = 2; // İleri hareket sensörünün Arduino pin numarası
const int backwardSensorPin = 3; // Geri hareket sensörünün Arduino pin numarası
const int startButtonPin = 4; // Pulse jeneratörünü başlatan buton için Arduino pin numarası
const int stopButtonPin = 5; // Pulse jeneratörünü durduran buton için Arduino pin numarası
const int pulseDelay = 500; // Pulse arasındaki bekleme süresi (milisaniye cinsinden)
bool forwardMotion = true; // İleri hareket kontrolü
bool isRunning = false; // Pulse jeneratörünün çalışma durumu
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(forwardSensorPin, INPUT); // İleri hareket sensörünü giriş moduna ayarla
pinMode(backwardSensorPin, INPUT); // Geri hareket sensörünü giriş moduna ayarla
pinMode(startButtonPin, INPUT_PULLUP); // Pulse jeneratörünü başlatan butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
pinMode(stopButtonPin, INPUT_PULLUP); // Pulse jeneratörünü durduran butonu giriş moduna ayarla ve dahili pull-up direncini etkinleştir
}
void loop() {
// Pulse jeneratörünü başlatan butonun durumunu oku
if (digitalRead(startButtonPin) == LOW) {
startGenerator(); // Pulse jeneratörünü başlat
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Pulse jeneratörünü durduran butonun durumunu oku
if (digitalRead(stopButtonPin) == LOW) {
stopGenerator(); // Pulse jeneratörünü durdur
delay(50); // Buton sinyalinin kararlı hale gelmesi için kısa bir gecikme yap
}
// Pulse jeneratörü çalışıyorsa
if (isRunning) {
// İleri hareket sensörünün durumunu oku
bool forwardSensor = digitalRead(forwardSensorPin);
// Geri hareket sensörünün durumunu oku
bool backwardSensor = digitalRead(backwardSensorPin);
// İleri hareket sensörü algıladığında veya geri hareket sensörü algılamadığında pulse jeneratörünü çalıştır
if (forwardSensor || !backwardSensor) {
runPulseGenerator();
}
}
}
// Pulse jeneratörünü başlatan fonksiyon
void startGenerator() {
isRunning = true; // Pulse jeneratörünün çalışma durum
unu etkinleştir
}
// Pulse jeneratörünü durduran fonksiyon
void stopGenerator() {
isRunning = false; // Pulse jeneratörünün çalışma durumunu devre dışı bırak
digitalWrite(outputPin, LOW); // Pulse çıkışını düşük yap
}
// Pulse jeneratörünü çalıştıran fonksiyon
void runPulseGenerator() {
// İleri hareket kontrolüne göre pulse jeneratörünü çalıştır
if (forwardMotion) {
generatePulse(true); // İleri hareket için pulse jeneratörünü çalıştır
} else {
generatePulse(false); // Geri hareket için pulse jeneratörünü çalıştır
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulse(bool forward) {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delay(pulseDelay); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(pulseDelay); // Pulse genişliği kadar bekle
// İleri hareket kontrolünü güncelle
forwardMotion = forward;
}
```
Yukarıdaki kodda, pulse jeneratörüne başlatma ve durdurma işlevleri için iki adet buton eklenmiştir. `startButtonPin`, pulse jeneratörünü başlatan butonun Arduino pin numarasını temsil eder. `stopButtonPin`, pulse jeneratörünü durduran butonun Arduino pin numarasını temsil eder.
`startGenerator()` fonksiyonu, pulse jeneratörünü başlatırken, `stopGenerator()` fonksiyonu pulse jeneratörünü durdurur. Pulse jeneratörü çalıştırılırken (`runPulseGenerator()` fonksiyonu), başlatma butonuna basılması gerekmektedir. Durdurma butonuna basıldığında (`stopGenerator()` fonksiyonu), pulse jeneratörü durdurulur.
Bu şekilde, start butonuna basıldığında pulse jeneratörü çalışacak ve stop butonuna basıldığında pulse jeneratörü duracaktır. İleri ve geri hareket sensörleri arasında sonsuz çalışan pulse jeneratörü oluşturulmuş olacaktır.
Hareket algılandığında 10 tur ileri 10 tur geri yapan pulse jeneratörü pır dedektör kullanarak
Tabii, işte bir örnek Arduino kodu, hareket algılandığında 10 tur ileri ve 10 tur geri hareket eden pulse jeneratörünü pır (PIR) dedektör kullanarak gerçekleştiren:
-----------------------------------------------------------------------
// PIR dedektörü ile 10 tur ileri ve 10 tur geri hareket eden pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int pirPin = 2; // PIR dedektörünün Arduino pin numarası
const int pulseDelay = 500; // Pulse arasındaki bekleme süresi (milisaniye cinsinden)
const int numPulses = 10; // Toplam pulse sayısı
bool forwardMotion = true; // İleri hareket kontrolü
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(pirPin, INPUT); // PIR dedektörünü giriş moduna ayarla
}
void loop() {
// PIR dedektörünün durumunu oku
int motionDetected = digitalRead(pirPin);
// Hareket algılandığında pulse jeneratörünü çalıştır
if (motionDetected == HIGH) {
runPulseGenerator();
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void runPulseGenerator() {
// İleri veya geri hareketi belirle
if (forwardMotion) {
generatePulses(numPulses); // İleri hareket için pulse jeneratörünü çalıştır
} else {
generatePulses(-numPulses); // Geri hareket için pulse jeneratörünü çalıştır
}
// İleri veya geri hareketi değiştir
forwardMotion = !forwardMotion;
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulses(int count) {
for (int i = 0; i < abs(count); i++) {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delay(pulseDelay); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(pulseDelay); // Pulse genişliği kadar bekle
}
}
```
Yukarıdaki kodda, PIR (pır) dedektör kullanılarak hareket algılandığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `pirPin`, PIR dedektörünün Arduino pin numarasını temsil eder.
`loop()` fonksiyonunda, PIR dedektörünün durumu okunur. Eğer hareket algılandığında (`motionDetected` değişkeni HIGH olarak okunursa), pulse jeneratörü çalıştırılır (`runPulseGenerator()` fonksiyonu çağrılır).
`runPulseGenerator()` fonksiyonu, pulse jenerat
örünü çalıştırır. İleri veya geri hareketi belirler ve pulse jeneratörünü ilgili yönde çalıştırır (`generatePulses()` fonksiyonunu çağırır). Ardından, ileri veya geri hareketi değiştirir.
`generatePulses()` fonksiyonu, belirli bir sayıda pulse oluşturur. İleri hareket için pozitif sayı, geri hareket için negatif sayı kullanılır. Pulse oluşturma işlemi belirli bir bekleme süresi (`pulseDelay`) ve pulse sayısı (`count`) ile gerçekleştirilir.
Bu şekilde, PIR dedektörü kullanarak hareket algılandığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörü oluşturabilirsiniz.
Işık gördüğünde 10 tur ileri 10 tur geri hareket sağlayan pulse jeneratör örneği
Tabii, işte bir örnek Arduino kodu, bir ışık sensörü kullanarak ışık algılandığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörünü gerçekleştiren:
-----------------------------------------------------------------------
// Işık sensörü ile 10 tur ileri ve 10 tur geri hareket eden pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int lightSensorPin = A0; // Işık sensörünün analog Arduino pin numarası
const int pulseDelay = 500; // Pulse arasındaki bekleme süresi (milisaniye cinsinden)
const int numPulses = 10; // Toplam pulse sayısı
bool forwardMotion = true; // İleri hareket kontrolü
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(lightSensorPin, INPUT); // Işık sensörünü giriş moduna ayarla
}
void loop() {
// Işık sensöründen okunan değeri al
int lightValue = analogRead(lightSensorPin);
// Işık algılandığında pulse jeneratörünü çalıştır
if (lightValue > 500) { // Algılama eşiğini kendi ihtiyaçlarınıza göre ayarlayabilirsiniz
runPulseGenerator();
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void runPulseGenerator() {
// İleri veya geri hareketi belirle
if (forwardMotion) {
generatePulses(numPulses); // İleri hareket için pulse jeneratörünü çalıştır
} else {
generatePulses(-numPulses); // Geri hareket için pulse jeneratörünü çalıştır
}
// İleri veya geri hareketi değiştir
forwardMotion = !forwardMotion;
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulses(int count) {
for (int i = 0; i < abs(count); i++) {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delay(pulseDelay); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(pulseDelay); // Pulse genişliği kadar bekle
}
}
```
Yukarıdaki kodda, bir ışık sensörü kullanılarak ışık algılandığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `lightSensorPin`, ışık sensörünün analog Arduino pin numarasını temsil eder.
`loop()` fonksiyonunda, ışık sensöründen okunan değer (`lightValue`), belirlenen eşik değerinden (`500` olarak belirtilmiş, ancak ihtiyaca göre değiştirilebilir) yüksekse,
pulse jeneratörü çalıştırılır (`runPulseGenerator()` fonksiyonu çağrılır).
`runPulseGenerator()` fonksiyonu, pulse jeneratörünü çalıştırır. İleri veya geri hareketi belirler ve pulse jeneratörünü ilgili yönde çalıştırır (`generatePulses()` fonksiyonunu çağırır). Ardından, ileri veya geri hareketi değiştirir.
`generatePulses()` fonksiyonu, belirli bir sayıda pulse oluşturur. İleri hareket için pozitif sayı, geri hareket için negatif sayı kullanılır. Pulse oluşturma işlemi belirli bir bekleme süresi (`pulseDelay`) ve pulse sayısı (`count`) ile gerçekleştirilir.
Bu şekilde, ışık algılandığında 10 tur ileri ve 10 tur geri hareket eden bir pulse jeneratörü oluşturabilirsiniz. Algılama eşik değerini ihtiyaca göre ayarlayarak hassasiyeti kontrol edebilirsiniz.
Duman algılandığında hareket eden pulse jeneratör
Duman algılandığında hareket eden bir pulse jeneratörü oluşturmak için bir duman sensörü ve hareket motorları kullanabilirsiniz. İşte bir örnek Arduino kodu:
-----------------------------------------------------------------------
// Duman sensörü ile hareket eden pulse jeneratörü için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int smokeSensorPin = A0; // Duman sensörünün analog Arduino pin numarası
const int pulseDelay = 500; // Pulse arasındaki bekleme süresi (milisaniye cinsinden)
const int numPulses = 10; // Toplam pulse sayısı
bool forwardMotion = true; // İleri hareket kontrolü
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(smokeSensorPin, INPUT); // Duman sensörünü giriş moduna ayarla
}
void loop() {
// Duman sensöründen okunan değeri al
int smokeValue = analogRead(smokeSensorPin);
// Duman algılandığında pulse jeneratörünü çalıştır
if (smokeValue > 500) { // Algılama eşiğini kendi ihtiyaçlarınıza göre ayarlayabilirsiniz
runPulseGenerator();
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void runPulseGenerator() {
// İleri veya geri hareketi belirle
if (forwardMotion) {
generatePulses(numPulses); // İleri hareket için pulse jeneratörünü çalıştır
} else {
generatePulses(-numPulses); // Geri hareket için pulse jeneratörünü çalıştır
}
// İleri veya geri hareketi değiştir
forwardMotion = !forwardMotion;
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulses(int count) {
for (int i = 0; i < abs(count); i++) {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delay(pulseDelay); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(pulseDelay); // Pulse genişliği kadar bekle
}
}
```
Yukarıdaki kodda, bir duman sensörü kullanılarak duman algılandığında hareket eden bir pulse jeneratörü oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `smokeSensorPin`, duman sensörünün analog Arduino pin numarasını temsil eder.
`loop()` fonksiyonunda, duman sensöründen okunan değer (`smokeValue`), belirlenen eşik değerinden (`500` olarak belirtilmiş, ancak ihtiyaca göre değiştirilebilir) yüksekse, pulse jeneratörü çalıştırılır (`runPulseGenerator()` fonksiyonu çağrılır).
`runPulseGenerator()` fon
ksiyonu, pulse jeneratörünü çalıştırır. İleri veya geri hareketi belirler ve pulse jeneratörünü ilgili yönde çalıştırır (`generatePulses()` fonksiyonunu çağırır). Ardından, ileri veya geri hareketi değiştirir.
`generatePulses()` fonksiyonu, belirli bir sayıda pulse oluşturur. İleri hareket için pozitif sayı, geri hareket için negatif sayı kullanılır. Pulse oluşturma işlemi belirli bir bekleme süresi (`pulseDelay`) ve pulse sayısı (`count`) ile gerçekleştirilir.
Bu şekilde, duman algılandığında hareket eden bir pulse jeneratörü oluşturabilirsiniz. Duman sensörü algılama eşiğini ihtiyaca göre ayarlayarak hassasiyeti kontrol edebilirsiniz.
Gürültü oldukça pulse veren jeneratör
Gürültü algılandığında pulse veren bir jeneratör oluşturmak için bir gürültü sensörü kullanabilirsiniz. İşte bir örnek Arduino kodu:
-----------------------------------------------------------------------
// Gürültü sensörü ile pulse veren jeneratör için Arduino kodu
const int outputPin = 9; // Pulse çıkışı için kullanılacak Arduino pin numarası
const int noiseSensorPin = A0; // Gürültü sensörünün analog Arduino pin numarası
const int pulseDelay = 500; // Pulse arasındaki bekleme süresi (milisaniye cinsinden)
const int pulseDuration = 100; // Pulse genişliği (milisaniye cinsinden)
void setup() {
pinMode(outputPin, OUTPUT); // Pulse çıkış pinini çıkış moduna ayarla
pinMode(noiseSensorPin, INPUT); // Gürültü sensörünü giriş moduna ayarla
}
void loop() {
// Gürültü sensöründen okunan değeri al
int noiseValue = analogRead(noiseSensorPin);
// Gürültü algılandığında pulse jeneratörünü çalıştır
if (noiseValue > 500) { // Algılama eşiğini kendi ihtiyaçlarınıza göre ayarlayabilirsiniz
generatePulse();
}
}
// Pulse jeneratörünü çalıştıran fonksiyon
void generatePulse() {
digitalWrite(outputPin, HIGH); // Pulse başlangıcında çıkış pinini yüksek yap
delay(pulseDuration); // Pulse genişliği kadar bekle
digitalWrite(outputPin, LOW); // Pulse sonunda çıkış pinini düşük yap
delay(pulseDelay); // Pulse arasındaki bekleme süresi kadar bekle
}
```
Yukarıdaki kodda, bir gürültü sensörü kullanılarak gürültü algılandığında pulse veren bir jeneratör oluşturulur. `outputPin`, pulse çıkışı için kullanılan Arduino pin numarasını temsil eder. `noiseSensorPin`, gürültü sensörünün analog Arduino pin numarasını temsil eder.
`loop()` fonksiyonunda, gürültü sensöründen okunan değer (`noiseValue`), belirlenen eşik değerinden (`500` olarak belirtilmiş, ancak ihtiyaca göre değiştirilebilir) yüksekse, pulse jeneratörü çalıştırılır (`generatePulse()` fonksiyonu çağrılır).
`generatePulse()` fonksiyonu, pulse oluşturma işlemini gerçekleştirir. Çıkış pini yüksek seviyeye ayarlanır, belirli bir süre boyunca (`pulseDuration`) bu seviyede tutulur ve ardından çıkış pini düşük seviyeye ayarlanır. Ardından, bir sonraki pulse oluşturulması için bekleme süresi (`pulseDelay`) kadar beklenir.
Bu şekilde, gürültü algılandığında pulse veren bir jeneratör oluşturabilirsiniz. Gürültü sensöründen
okunan değerin eşiğini ihtiyaca göre ayarlayarak hassasiyeti kontrol edebilirsiniz.
