Análisis de la respuesta temporal del pinout del PLC Raspberry Pi

#include <iostream>
#include <chrono>
#include <rpiplc.h>
#include "common.h"

int main() {

  initPins();
  pinMode(digitalOutputs[0], OUTPUT);
  bool a = true;

  for (;;) {

    auto start = std::chrono::high_resolution_clock::now();
    digitalWrite(digitalOutputs[0], a);
    auto end = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    std::cout << "Execution time: " << duration << " microseconds" << std::endl;

    a = !a;
    usleep(10000);
  }
  return 0;
}

from rpiplc_lib import rpiplc
import time

usleep = lambda x: time.sleep(x/1000000.0)

def main():
        rpiplc.init("RPIPLC_21")
        a=True
        rpiplc.pin_mode("Q0.0", rpiplc.OUTPUT)

        while True:
                a = not a
                start = time.time()
                rpiplc.digital_write("Q0.0", a)
                end = time.time()
                res = ( end - start )
                print(res)
                usleep(10000)

if __name__ == "__main__":
        main()

#include <iostream>
#include <chrono>
#include <rpiplc.h>
#include "common.h"

#define PIN digitalInputs[0]
#define READ_TYPE digitalRead
#define N_AVERAGE 10000

int main() {
	initPins();
	pinMode(PIN, INPUT);

	unsigned long t_max, t_average;
	for (long i = 0; i < N_AVERAGE; i++) {
		auto t1 = std::chrono::high_resolution_clock::now();
		READ_TYPE(PIN);
		auto t2 = std::chrono::high_resolution_clock::now();
		auto duration = std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
		t_average += duration;
 		if (t_max < duration) t_max = duration;
	}
	std::cout << "Average: " << t_average/N_AVERAGE << " microseconds" << std::endl;
	std::cout << "Maximum: " << t_max << " microseconds" << std::endl;

	return 0;
}

from rpiplc_lib import rpiplc
import time

PIN = "I0.7"
READ_TYPE = rpiplc.digital_read
N_AVERAGE = 10000

def main():
        rpiplc.init("RPIPLC_21")
        rpiplc.pin_mode(PIN, rpiplc.INPUT)

        t_max = 0; t_average = 0;
        for i in range(N_AVERAGE):
                start = time.perf_counter()
                READ_TYPE(PIN)
                end = time.perf_counter()
                res = (end - start) * 1e6
                t_average += res
                if t_max < res: t_max = res

        print("Average: {}\nMaximum: {}".format(t_average/float(N_AVERAGE), t_max))

if __name__ == "__main__":
        main()

#include <iostream>
#include <chrono>
#include <rpiplc.h>
#include "common.h"

int main() {

  initPins();
  pinMode(analogOutputs[0], OUTPUT);
  int a = 4095;

  for (;;) {

    auto start = std::chrono::high_resolution_clock::now();
    analogWrite(analogOutputs[0], a);
    auto end = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
    std::cout << "Execution time: " << duration << " microseconds" << std::endl;

    usleep(1000000);
    a = (a == 4095) ? 0 : 4095;
  }
  return 0;
}

from rpiplc_lib import rpiplc
import time

usleep = lambda x: time.sleep(x/1000000.0)

def main():
        rpiplc.init("RPIPLC_21")
        a=4095
        rpiplc.pin_mode("A0.5", rpiplc.OUTPUT)

        while True:
                if a == 4095: a = 0
                else: a = 4095
                start = time.time()
                rpiplc.analog_write("A0.5", a)
                end = time.time()
                res = ( end - start )
                print(res)
                usleep(1000000)

if __name__ == "__main__":
        main()

#include <iostream>
#include <chrono>
#include <rpiplc.h>
#include "common.h"

int main() {

  initPins();
  pinMode(analogInputs[0], INPUT);

  for (;;) {
 
    auto start = std::chrono::high_resolution_clock::now();
    int a = analogRead(analogInputs[0]);
    auto end = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    std::cout << "Execution time: " << duration << " microseconds" << std::endl;
    std::cout << "Read result: " << a << std::endl;
  }
  return 0;
}

from rpiplc_lib import rpiplc
import time

usleep = lambda x: time.sleep(x/1000000.0)

def main():
        rpiplc.init("RPIPLC_21")
        rpiplc.pin_mode("I0.7", rpiplc.INPUT)

        while True:
                start = time.time()
                a = rpiplc.analog_read("I0.7")
                end = time.time()
                res = ( end - start )
                print(res)
                print(a)
                usleep(1000000)

if __name__ == "__main__":
        main()

#include <pigpio.h>
#include <iostream>
#include <thread>

#define PIN 8
#define DELAY_NS 8*1000

void delayNanoSeconds(unsigned int nanoseconds) {
  auto start = std::chrono::high_resolution_clock::now();
  auto end = start + std::chrono::nanoseconds(nanoseconds);
  while (std::chrono::high_resolution_clock::now() < end);
}

int main() {
  if (gpioInitialise() < 0) {
    std::cout << "Failed to initialize pigpio library." << std::endl;
    return 1;
  }
  gpioSetMode(PIN, PI_OUTPUT);
  while (1) {
    gpioWrite(PIN, 1);
    delayNanoSeconds(DELAY_NS);
    gpioWrite(PIN, 0);
    delayNanoSeconds(DELAY_NS);
  }
}

from gpiozero import LED

led = LED(14)

while True:
    led.on()
    led.off()

from gpiozero import Button
import time

button = Button(8)
N_AVERAGE = 10000

def main():
        t_max = 0; t_average = 0;
        for i in range(N_AVERAGE):
                start = time.perf_counter()
                button.is_pressed;
                end = time.perf_counter()
                res = (end - start) * 1e6
                t_average += res
                if t_max < res: t_max = res

        print("Average: {}\nMaximum: {}".format(t_average/float(N_AVERAGE), t_max))

if __name__ == "__main__":
        main()