@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/examples/networking/udp-multicast.c

@@ -0,0 +1,220 @@
+/**
+ * @file udp-multicast.c
+ * @brief Example UDP multicast sender and receiver
+ * 
+ * This example demonstrates:
+ * - UDP multicast group management
+ * - Sending multicast packets
+ * - Receiving multicast packets
+ * - Socket options for multicast
+ * - Error handling
+ * 
+ * Compile: gcc -Wall -Wextra -std=c11 -o udp-multicast udp-multicast.c
+ * Run sender: ./udp-multicast send 239.0.0.1 5000
+ * Run receiver: ./udp-multicast recv 239.0.0.1 5000
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <time.h>
+
+#define BUFFER_SIZE 1024
+#define MULTICAST_TTL 32
+
+/**
+ * @brief Create multicast sender socket
+ */
+static int create_multicast_sender(const char *group_addr, uint16_t port,
+                                   struct sockaddr_in *dest_addr) {
+    int sockfd;
+    unsigned char ttl = MULTICAST_TTL;
+    
+    /* Create UDP socket */
+    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sockfd < 0) {
+        perror("socket");
+        return -1;
+    }
+    
+    /* Set multicast TTL */
+    if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
+        perror("setsockopt(IP_MULTICAST_TTL)");
+        close(sockfd);
+        return -1;
+    }
+    
+    /* Setup destination address */
+    memset(dest_addr, 0, sizeof(*dest_addr));
+    dest_addr->sin_family = AF_INET;
+    dest_addr->sin_port = htons(port);
+    if (inet_aton(group_addr, &dest_addr->sin_addr) == 0) {
+        fprintf(stderr, "Invalid multicast address\n");
+        close(sockfd);
+        return -1;
+    }
+    
+    printf("Multicast sender created for %s:%u\n", group_addr, port);
+    return sockfd;
+}
+
+/**
+ * @brief Create multicast receiver socket
+ */
+static int create_multicast_receiver(const char *group_addr, uint16_t port) {
+    int sockfd;
+    struct sockaddr_in local_addr;
+    struct ip_mreq mreq;
+    int reuse = 1;
+    
+    /* Create UDP socket */
+    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sockfd < 0) {
+        perror("socket");
+        return -1;
+    }
+    
+    /* Allow multiple receivers on same port */
+    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
+        perror("setsockopt(SO_REUSEADDR)");
+        close(sockfd);
+        return -1;
+    }
+    
+    /* Bind to multicast port */
+    memset(&local_addr, 0, sizeof(local_addr));
+    local_addr.sin_family = AF_INET;
+    local_addr.sin_addr.s_addr = INADDR_ANY;
+    local_addr.sin_port = htons(port);
+    
+    if (bind(sockfd, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
+        perror("bind");
+        close(sockfd);
+        return -1;
+    }
+    
+    /* Join multicast group */
+    memset(&mreq, 0, sizeof(mreq));
+    if (inet_aton(group_addr, &mreq.imr_multiaddr) == 0) {
+        fprintf(stderr, "Invalid multicast address\n");
+        close(sockfd);
+        return -1;
+    }
+    mreq.imr_interface.s_addr = INADDR_ANY;
+    
+    if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
+        perror("setsockopt(IP_ADD_MEMBERSHIP)");
+        close(sockfd);
+        return -1;
+    }
+    
+    printf("Multicast receiver joined group %s:%u\n", group_addr, port);
+    return sockfd;
+}
+
+/**
+ * @brief Run multicast sender
+ */
+static void run_sender(int sockfd, struct sockaddr_in *dest_addr) {
+    char buffer[BUFFER_SIZE];
+    int count = 0;
+    
+    printf("Sending multicast messages (Ctrl+C to stop)...\n");
+    
+    while (1) {
+        /* Create message with timestamp */
+        time_t now = time(NULL);
+        snprintf(buffer, sizeof(buffer), 
+                "Multicast message #%d at %s", count++, ctime(&now));
+        
+        /* Send multicast packet */
+        ssize_t sent = sendto(sockfd, buffer, strlen(buffer), 0,
+                             (struct sockaddr *)dest_addr, sizeof(*dest_addr));
+        if (sent < 0) {
+            perror("sendto");
+            break;
+        }
+        
+        printf("Sent: %s", buffer);
+        sleep(2);  /* Send every 2 seconds */
+    }
+}
+
+/**
+ * @brief Run multicast receiver
+ */
+static void run_receiver(int sockfd) {
+    char buffer[BUFFER_SIZE];
+    struct sockaddr_in sender_addr;
+    socklen_t sender_len;
+    
+    printf("Receiving multicast messages (Ctrl+C to stop)...\n");
+    
+    while (1) {
+        sender_len = sizeof(sender_addr);
+        ssize_t received = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0,
+                                   (struct sockaddr *)&sender_addr, &sender_len);
+        
+        if (received < 0) {
+            perror("recvfrom");
+            break;
+        }
+        
+        buffer[received] = '\0';
+        printf("Received from %s:%u: %s",
+               inet_ntoa(sender_addr.sin_addr),
+               ntohs(sender_addr.sin_port),
+               buffer);
+    }
+}
+
+/**
+ * @brief Main function
+ */
+int main(int argc, char *argv[]) {
+    int sockfd;
+    const char *mode, *group_addr;
+    uint16_t port;
+    
+    /* Parse arguments */
+    if (argc != 4) {
+        fprintf(stderr, "Usage: %s <send|recv> <multicast_addr> <port>\n", argv[0]);
+        fprintf(stderr, "Example: %s send 239.0.0.1 5000\n", argv[0]);
+        fprintf(stderr, "         %s recv 239.0.0.1 5000\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+    
+    mode = argv[1];
+    group_addr = argv[2];
+    port = (uint16_t)atoi(argv[3]);
+    
+    if (strcmp(mode, "send") == 0) {
+        /* Sender mode */
+        struct sockaddr_in dest_addr;
+        sockfd = create_multicast_sender(group_addr, port, &dest_addr);
+        if (sockfd < 0) {
+            return EXIT_FAILURE;
+        }
+        run_sender(sockfd, &dest_addr);
+    } else if (strcmp(mode, "recv") == 0) {
+        /* Receiver mode */
+        sockfd = create_multicast_receiver(group_addr, port);
+        if (sockfd < 0) {
+            return EXIT_FAILURE;
+        }
+        run_receiver(sockfd);
+    } else {
+        fprintf(stderr, "Invalid mode: %s (use 'send' or 'recv')\n", mode);
+        return EXIT_FAILURE;
+    }
+    
+    close(sockfd);
+    return EXIT_SUCCESS;
+}
+

package/augment-extensions/coding-standards/c/examples/realtime/Makefile

@@ -0,0 +1,53 @@
+# Makefile for Real-Time Systems Examples
+# Requires FreeRTOS or compatible RTOS
+
+# FreeRTOS paths (adjust for your installation)
+FREERTOS_DIR ?= /opt/FreeRTOS
+FREERTOS_SRC = $(FREERTOS_DIR)/Source
+FREERTOS_PORT = $(FREERTOS_SRC)/portable/GCC/ARM_CM3
+
+CC = arm-none-eabi-gcc
+CFLAGS = -Wall -Wextra -std=c11 -O2
+CFLAGS += -mcpu=cortex-m3 -mthumb
+CFLAGS += -DUSE_FREERTOS
+CFLAGS += -I$(FREERTOS_SRC)/include
+CFLAGS += -I$(FREERTOS_PORT)
+CFLAGS += -I.
+
+# Source files
+SRCS = priority-scheduling.c deadline-monitoring.c
+
+# For host compilation (testing structure only)
+HOST_CC = gcc
+HOST_CFLAGS = -Wall -Wextra -std=c11 -O2
+
+.PHONY: all clean host-test
+
+# Default target (requires RTOS)
+all:
+	@echo "This requires FreeRTOS or compatible RTOS"
+	@echo "Set FREERTOS_DIR to your FreeRTOS installation"
+	@echo "Or use 'make host-test' for syntax checking"
+
+# Host compilation for syntax checking
+host-test:
+	$(HOST_CC) $(HOST_CFLAGS) -c priority-scheduling.c -o priority-scheduling.o
+	$(HOST_CC) $(HOST_CFLAGS) -c deadline-monitoring.c -o deadline-monitoring.o
+	@echo "Syntax check passed"
+
+clean:
+	rm -f *.o *.elf *.bin
+
+help:
+	@echo "Real-Time Systems Examples Makefile"
+	@echo "===================================="
+	@echo "Targets:"
+	@echo "  all        - Build for target (requires RTOS)"
+	@echo "  host-test  - Syntax check on host"
+	@echo "  clean      - Remove build artifacts"
+	@echo ""
+	@echo "Requirements:"
+	@echo "  - FreeRTOS or compatible RTOS"
+	@echo "  - ARM GCC toolchain (for embedded)"
+	@echo "  - GCC (for host testing)"
+

package/augment-extensions/coding-standards/c/examples/realtime/README.md

@@ -0,0 +1,199 @@
+# Real-Time Systems Examples
+
+This directory contains real-time programming examples demonstrating RTOS concepts and deadline monitoring.
+
+## Examples
+
+### 1. priority-scheduling.c
+Priority-based task scheduling:
+- Multiple tasks with different priorities
+- Priority-based preemption
+- Mutex with priority inheritance
+- Periodic and aperiodic tasks
+- Event-driven processing
+
+**Key Concepts:**
+- Higher priority tasks preempt lower priority
+- Use `vTaskDelayUntil()` for periodic tasks
+- Priority inheritance prevents priority inversion
+- Event queues for aperiodic events
+
+### 2. deadline-monitoring.c
+Deadline monitoring and tracking:
+- Execution time measurement
+- Deadline miss detection
+- WCET (Worst-Case Execution Time) tracking
+- Task timing statistics
+- Watchdog timer for enforcement
+
+**Key Concepts:**
+- Monitor execution time for each task instance
+- Detect and log deadline misses
+- Track min/max/average execution times
+- Use watchdog timers for safety
+
+## Building
+
+### For FreeRTOS
+
+```bash
+# Set FreeRTOS path
+export FREERTOS_DIR=/path/to/FreeRTOS
+
+# Build (requires ARM toolchain)
+make
+```
+
+### For Host Testing (Syntax Check)
+
+```bash
+# Compile for syntax checking only
+make host-test
+```
+
+## RTOS Integration
+
+These examples are designed for FreeRTOS but can be adapted for:
+- **Zephyr RTOS**: Replace FreeRTOS API with Zephyr equivalents
+- **RTEMS**: Use RTEMS Classic API
+- **VxWorks**: Use VxWorks task API
+- **POSIX Real-Time**: Use pthread with real-time scheduling
+
+## Real-Time Concepts
+
+### Priority Scheduling
+
+Tasks are scheduled based on priority:
+```c
+xTaskCreate(task_func, "Task", stack_size, NULL, PRIORITY_HIGH, NULL);
+```
+
+Priority levels (example):
+- **High (3)**: Critical control loops, ISR handlers
+- **Medium (2)**: Data processing, communication
+- **Low (1)**: Background tasks, logging
+
+### Deadline Monitoring
+
+Monitor task execution time:
+```c
+uint32_t start = get_time_us();
+/* Do work */
+uint32_t end = get_time_us();
+uint32_t execution_time = end - start;
+
+if (execution_time > deadline) {
+    /* Deadline miss! */
+}
+```
+
+### Priority Inheritance
+
+Prevent priority inversion:
+```c
+/* Create mutex with priority inheritance */
+SemaphoreHandle_t mutex = xSemaphoreCreateMutex();
+
+/* Low priority task holding mutex inherits high priority */
+xSemaphoreTake(mutex, timeout);
+/* Critical section */
+xSemaphoreGive(mutex);
+```
+
+## Best Practices
+
+1. **Task Design**
+   - Keep tasks simple and focused
+   - Use appropriate priorities
+   - Avoid blocking in high-priority tasks
+   - Use timeouts on all blocking calls
+
+2. **Timing**
+   - Use `vTaskDelayUntil()` for periodic tasks
+   - Monitor execution times
+   - Set realistic deadlines
+   - Track WCET
+
+3. **Synchronization**
+   - Use mutexes with priority inheritance
+   - Minimize critical sections
+   - Avoid nested locks
+   - Use queues for inter-task communication
+
+4. **Resource Management**
+   - Allocate resources at initialization
+   - Avoid dynamic allocation in tasks
+   - Use static allocation when possible
+   - Clean up resources properly
+
+## Common Pitfalls
+
+1. **Priority Inversion**
+   ```c
+   // WRONG - No priority inheritance
+   SemaphoreHandle_t sem = xSemaphoreCreateBinary();
+   
+   // CORRECT - Use mutex with priority inheritance
+   SemaphoreHandle_t mutex = xSemaphoreCreateMutex();
+   ```
+
+2. **Missed Deadlines**
+   ```c
+   // WRONG - No deadline monitoring
+   void task(void *params) {
+       while (1) {
+           do_work();  // How long does this take?
+           vTaskDelay(period);
+       }
+   }
+   
+   // CORRECT - Monitor execution time
+   void task(void *params) {
+       while (1) {
+           uint32_t start = get_time_us();
+           do_work();
+           uint32_t elapsed = get_time_us() - start;
+           if (elapsed > deadline) {
+               log_deadline_miss();
+           }
+           vTaskDelay(period);
+       }
+   }
+   ```
+
+3. **Blocking in High-Priority Tasks**
+   ```c
+   // WRONG - Blocking indefinitely
+   void high_priority_task(void *params) {
+       while (1) {
+           xQueueReceive(queue, &data, portMAX_DELAY);  // Bad!
+       }
+   }
+   
+   // CORRECT - Use timeout
+   void high_priority_task(void *params) {
+       while (1) {
+           if (xQueueReceive(queue, &data, pdMS_TO_TICKS(10)) == pdTRUE) {
+               process_data(&data);
+           }
+       }
+   }
+   ```
+
+## Performance Metrics
+
+Track these metrics for real-time tasks:
+- **Execution time**: Min, max, average
+- **Deadline misses**: Count and percentage
+- **Jitter**: Variation in execution time
+- **Response time**: Time from event to completion
+- **CPU utilization**: Percentage of time busy
+
+## References
+
+- FreeRTOS Documentation: https://www.freertos.org/
+- "Real-Time Systems" by Jane W. S. Liu
+- "Hard Real-Time Computing Systems" by Giorgio Buttazzo
+- Rate Monotonic Analysis (RMA)
+- Earliest Deadline First (EDF) scheduling
+