Z

README.md

@@ -128,3 +128,13 @@ BUENOS DIAS :)
 ADIOS 
 hola willy
 HOla reyes
+
+feliz cumpleaños willy
+GOLFITO
+Paso por ti a las 2 ve arreglandote ;)
+
+Feliz cumpleaños willito :)
+Buena willito kchon
+
+
+nn

Reyes_Pa/Reyes_Pa/Fino.py

@@ -0,0 +1,39 @@
+import rclpy
+from rclpy.node import Node
+
+from std_msgs.msg import String
+
+
+class MinimalPublisher(Node):
+
+    def __init__(self):
+        super().__init__('Nodo_Reyes')
+        self.publisher_ = self.create_publisher(String, 'RPM', 10)
+        timer_period = 0.5  # seconds
+        self.timer = self.create_timer(timer_period, self.timer_callback)
+        self.i = 0
+
+    def timer_callback(self):
+        msg = String()
+        msg.data = str(3)
+        self.publisher_.publish(msg)
+        self.get_logger().info('Publishing: "%s"' % msg.data)
+        self.i += 1
+
+
+def main(args=None):
+    rclpy.init(args=args)
+
+    minimal_publisher = MinimalPublisher()
+
+    rclpy.spin(minimal_publisher)
+
+    # Destroy the node explicitly
+    # (optional - otherwise it will be done automatically
+    # when the garbage collector destroys the node object)
+    minimal_publisher.destroy_node()
+    rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/P1_EnvFoto.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+import cv2
+import numpy as np
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import Image
+from cv_bridge import CvBridge
+
+class ImagePublisher(Node):
+
+    def __init__(self):
+        super().__init__('image_publisher')
+        self.publisher_ = self.create_publisher(Image, 'ALO', 10)
+        self.timer_ = self.create_timer(0.1, self.publish_image)
+        self.bridge_ = CvBridge()
+
+    def publish_image(self):
+        # Creamos una imagen de 640x480 píxeles con tres canales (BGR)
+        image = np.zeros((480, 640, 3), np.uint8)
+        # Dibujamos un círculo azul en el centro de la imagen
+        cv2.circle(image, (320, 240), 100, (255, 0, 0), -1)
+        # Convertimos la imagen a un mensaje de ROS
+        msg = self.bridge_.cv2_to_imgmsg(image, 'bgr8')
+        # Publicamos el mensaje
+        self.publisher_.publish(msg)
+        self.get_logger().info('Imagen publicada')
+
+def main(args=None):
+    rclpy.init(args=args)
+    node = ImagePublisher()
+    rclpy.spin(node)
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/P1_RecFoto.py

@@ -0,0 +1,29 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import Image
+
+
+class ImageSubscriber(Node):
+
+    def __init__(self):
+        super().__init__('image_subscriber')
+        self.subscription = self.create_subscription(
+            Image,
+            'ALO',
+            self.listener_callback,
+            10)
+        self.subscription  # prevent unused variable warning
+
+    def listener_callback(self, msg):
+        self.get_logger().info('Received an image!')  # add your own code here to process the image data
+
+
+def main(args=None):
+    rclpy.init(args=args)
+    node = ImageSubscriber()
+    rclpy.spin(node)
+    rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/P2_EnvFoto.py

@@ -0,0 +1,29 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import Image
+from cv_bridge import CvBridge
+import cv2
+
+
+class ImagePublisher(Node):
+
+    def __init__(self):
+        super().__init__('image_publisher')
+        self.publisher_ = self.create_publisher(Image, 'ALO', 10)
+        self.timer = self.create_timer(0.1, self.timer_callback)
+        self.bridge = CvBridge()
+
+    def timer_callback(self):
+        img = cv2.imread('/home/z3rn291/poderoso/src/Reyes_Pa/Reyes_Pa/JACHAS.jpg')
+        msg = self.bridge.cv2_to_imgmsg(img, encoding='bgr8')
+        self.publisher_.publish(msg)
+        self.get_logger().info('Image published!')
+
+def main(args=None):
+    rclpy.init(args=args)
+    node = ImagePublisher()
+    rclpy.spin(node)
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/Prueba.py

@@ -0,0 +1,31 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import Image
+from cv_bridge import CvBridge
+import cv2
+
+
+class MiNodo(Node):
+
+    def __init__(self):
+        super().__init__('ReyesN')
+        self.subscription = self.create_subscription(Image, 'ALO', self.imagen_callback, 10)
+        self.cv_bridge = CvBridge()
+
+    def imagen_callback(self, msg):
+        # convierte el mensaje de imagen en una matriz numpy utilizando cv_bridge
+        imagen = self.cv_bridge.imgmsg_to_cv2(msg, desired_encoding='bgr8')
+
+        # muestra la imagen en una ventana de OpenCV
+        cv2.imshow('Imagen recibida', imagen)
+        cv2.waitKey(1)
+
+def main(args=None):
+    rclpy.init(args=args)
+    mi_nodo = MiNodo()
+    rclpy.spin(mi_nodo)
+    mi_nodo.destroy_node()
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/T1_PubRPM.py

@@ -0,0 +1,39 @@
+import rclpy
+from rclpy.node import Node
+
+from std_msgs.msg import String
+
+
+class MinimalPublisher(Node):
+
+    def __init__(self):
+        super().__init__('CR_T1_PUBRPM')
+        self.publisher_ = self.create_publisher(String, 'RPM', 10)
+        timer_period = 0.5  # seconds
+        self.timer = self.create_timer(timer_period, self.timer_callback)
+        self.i = 0
+
+    def timer_callback(self):
+        msg = String()
+        msg.data = str(3)
+        self.publisher_.publish(msg)
+        self.get_logger().info('Publishing: "%s"' % msg.data)
+        self.i += 1
+
+
+def main(args=None):
+    rclpy.init(args=args)
+
+    minimal_publisher = MinimalPublisher()
+
+    rclpy.spin(minimal_publisher)
+
+    # Destroy the node explicitly
+    # (optional - otherwise it will be done automatically
+    # when the garbage collector destroys the node object)
+    minimal_publisher.destroy_node()
+    rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/T1_PubSub.py

@@ -0,0 +1,39 @@
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import String
+
+class MyNode(Node):
+
+    def __init__(self):
+        super().__init__('willypoder')
+        self.declare_parameter('Radio', 0.10)
+        sub_topic = self.get_parameter('Radio').value
+        self.publisher_ = self.create_publisher(String, 'lineal_speed', 10)
+        self.subscription = self.create_subscription(
+            String,
+            'RPM',
+            self.listener_callback,
+            10)
+        self.subscription  # prevent unused variable warning
+
+    def listener_callback(self, msg):
+        #self.get_logger().info('I heard: "%s"' % msg.data)
+        Radio = self.get_parameter('Radio').value
+
+        numin=(float(msg.data)/60)*2*3.141516*Radio
+        print(numin)
+        msg.data=str(numin)
+        self.publisher_.publish(msg)
+
+def main(args=None):
+    rclpy.init(args=args)
+
+    my_node = MyNode()
+
+    rclpy.spin(my_node)
+
+    my_node.destroy_node()
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/T1_SubLinSpeed.py

@@ -0,0 +1,36 @@
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import String
+
+
+class MinimalSubscriber(Node):
+
+    def __init__(self):
+        super().__init__('CR_T1_SubLinSpeed')
+        self.subscription = self.create_subscription(
+            String,
+            'lineal_speed',
+            self.listener_callback,
+            10)
+        self.subscription  # prevent unused variable warning
+
+    def listener_callback(self, msg):
+        self.get_logger().info('I heard: "%s"' % msg.data)
+
+
+def main(args=None):
+    rclpy.init(args=args)
+
+    minimal_subscriber = MinimalSubscriber()
+
+    rclpy.spin(minimal_subscriber)
+
+    # Destroy the node explicitly
+    # (optional - otherwise it will be done automatically
+    # when the garbage collector destroys the node object)
+    minimal_subscriber.destroy_node()
+    rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/T2_Cliente.py

@@ -0,0 +1,29 @@
+import rclpy
+from rclpy.node import Node
+from example_interfaces.srv import AddTwoInts
+
+def main(args=None):
+    rclpy.init(args=args)
+
+    node = rclpy.create_node('minimal_client')
+
+    client = node.create_client(AddTwoInts, 'add_two_ints')
+    while not client.wait_for_service(timeout_sec=1.0):
+        node.get_logger().info('service not available, waiting again...')
+    request = AddTwoInts.Request()
+    request.a = 3
+    request.b = 1
+    future = client.call_async(request)
+    rclpy.spin_until_future_complete(node, future)
+    if future.result() is not None:
+        response = future.result()
+        node.get_logger().info('Result of add_two_ints: %d' % (response.sum,))
+    else:
+        node.get_logger().info('Service call failed %r' % (future.exception(),))
+
+    node.destroy_node()
+    rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

Reyes_Pa/Reyes_Pa/T2_Cliente1.py

@@ -0,0 +1,43 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import Image
+from lolito_interfaces.srv import CaptureImage
+
+
+class Client(Node):
+
+    def __init__(self):
+        super().__init__('client_node')
+        self.client = self.create_client(CaptureImage, 'capture_image')
+        while not self.client.wait_for_service(timeout_sec=1.0):
+            self.get_logger().info('Servidor no disponible')
+        self.request = CaptureImage.Request()
+
+    def send_request(self):
+        self.request.req = True
+        self.future = self.client.call_async(self.request)
+
+    def get_response(self):
+        while rclpy.ok():
+            rclpy.spin_once(self)
+            if self.future.done():
+                try:
+                    response = self.future.result()
+                    img_data = response.my_image
+                    # Aquí puedes hacer lo que necesites con la imagen recibida
+                    break
+                except Exception as e:
+                    self.get_logger().info('Servicio fallido %r' % (e,))
+                    break
+
+
+def main(args=None):
+    rclpy.init(args=args)
+    client = Client()
+    client.send_request()
+    client.get_response()
+    rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()