Sergey Lyubka cpq

## bsd.c
// Source for the https://www.youtube.com/watch?v=pp9AM5A1mDs
// Written & tested on MacOS

#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

## Stack.md

      
              1 file
            
          
              12 forks
            
          
              6 comments
            
          
              32 stars
            
          
                cpq
                / Stack.md
            
            
              Last active
              April 27, 2024 12:27
            
              
                Why stack grows down
              
          
    Why stack grows down

Any running process has several memory regions: code, read-only data, read-write data, et cetera. Some regions, such as code and read-only data, are static and do not change over time. Other regions are dynamic: they can expand and shrink. Usually there are two such regions: dynamic read-write data region, called heap, and a region called stack. Heap holds dynamic memory allocations, and stack is mostly used for keeping function frames.
Both stack and heap can grow. An OS doesn't know in advance whether stack or heap will be used predominantly. Therefore, an OS must layout these two memory regions in a way to guarantee maximum space for both. And here is the solution:

Layout static memory regions at the edges of process's virtual memory
Put heap and stack on edges too, and let them grow towards each other: one grows up, one grows down


## preact-modal.html
<!DOCTYPE html>
<html lang="en">
  <head>
    <title>modal</title>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/5.1.0/css/bootstrap.min.css" />
  </head>
  <body></body>

## embed.c
// Copyright (c) Sergey Lyubka, 2013.
// All rights reserved.
// Released under the MIT license.

// This program is used to embed arbitrary data into a C binary. It takes
// a list of files as an input, and produces a .c data file that contains
// contents of all these files as collection of char arrays.
// Usage:
//   1. Compile this file:
//      cc -o embed embed.c

## rt1060.sh
#!/bin/bash
# SWD commands to call rt1060 flash boot rom functions

DEVCALL="curl -su :$VCON_API_KEY https://dash.vcon.io/api/v3/devices/13"

# SWD exec: se COMMANDS. Hex addresses are without leading 0x
se() { $DEVCALL/rpc/swd.exec -d "{\"req\": \"$*\"}" | jq -cr .resp ; }
rm() { se rm,$1 | cut -d, -f2 ; }
dump() { $DEVCALL/rpc/swd.read -d "{\"addr\":$1, \"size\": $2}" | jq -r .data | xxd -r -p | hexdump -C ; }
hex() { node -p "($*).toString(16)"; }

## stm32.md

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                cpq
                / stm32.md
            
            
              Last active
              September 26, 2023 09:56
            
              
                STM32 naming
              
          
    STM32	naming scheme

Example MCU: STM32 H743ZI


Example
Type
Description


H
Type
F: mainstream, L: low power, H: high performance, W: wireless


7
Core
0: M0, 1: M3, 2: M3, 3: M4, 4: M4, 7: M7


23
Line
speed, peripherals, silicon process, …


Z
Pin count
F: 20, G: 28, K: 32, T: 36, S: 44, C: 48, R: 64,66, V: 100, Z: 144, I: 176


## Mutex.md

      
              1 file
            
          
              2 forks
            
          
              2 comments
            
          
              10 stars
            
          
                cpq
                / Mutex.md
            
            
              Last active
              May 14, 2023 18:15
            
              
                What is a mutex and how does it work
              
          
    What is a mutex and how does it work

Imagine a big office (your program), with many assets (shared resources)
and many employees (threads). For example, all employees share one common
resource - a toilet. They have agreed to use a label on a toilet's door (mutex).
When an employee wants to use the toilet he checks a label on a door
(locks a mutex). If it is "engaged" he waits (blocks on a mutex),
then when it is "free", he enters the toilet and changes the label to

  
## Hash.md

      
              1 file
            
          
              1 fork
            
          
              1 comment
            
          
              5 stars
            
          
                cpq
                / Hash.md
            
            
              Created
              January 24, 2014 14:35
            
              
                What is a hash and how does it work
              
          
    What is a hash and how does it work

Let us start from a practical example. Imagine we are writing
a traffic monitoring application. The purpose of application would be
to calculate a number of bytes sent by each IP address. To do that,
let create a structure that does that accounting:
struct ipstat {

uint32_t ip; /* Source IP address */

  
## slip.h
// Copyright (c) Cesanta Software Limited
// All rights reserved
// SPDX-License-Identifier: MIT

// Usage example (Arduino):
//      char buf[100];
//      struct slip slip = {.buf = buf, .size = sizeof(buf) - 1};
//      ...
//      unsigned char c = Serial.read();
//      size_t len = slip_recv(c, &slip);

## queue2.c
#include <sttdef.h>

// Single producer, single consumer non-blocking queue
//
// Producer:
//    void *buf;
//    while (mg_queue_space(q, &buf, len) == 0) WAIT();  // Wait for free space
//    memcpy(buf, data, len);  // Copy data to the queue
//    mg_queue_add(q, len);    // Advance q->head
//
	// Source for the https://www.youtube.com/watch?v=pp9AM5A1mDs
	// Written & tested on MacOS

	#include <arpa/inet.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <netinet/in.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<title>modal</title>
	<meta charset="utf-8" />
	<meta http-equiv="X-UA-Compatible" content="IE=edge" />
	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/5.1.0/css/bootstrap.min.css" />
	</head>
	<body></body>
	// Copyright (c) Sergey Lyubka, 2013.
	// All rights reserved.
	// Released under the MIT license.

	// This program is used to embed arbitrary data into a C binary. It takes
	// a list of files as an input, and produces a .c data file that contains
	// contents of all these files as collection of char arrays.
	// Usage:
	// 1. Compile this file:
	// cc -o embed embed.c
	#!/bin/bash
	# SWD commands to call rt1060 flash boot rom functions

	DEVCALL="curl -su :$VCON_API_KEY https://dash.vcon.io/api/v3/devices/13"

	# SWD exec: se COMMANDS. Hex addresses are without leading 0x
	se() { $DEVCALL/rpc/swd.exec -d "{\"req\": \"$*\"}" \| jq -cr .resp ; }
	rm() { se rm,$1 \| cut -d, -f2 ; }
	dump() { $DEVCALL/rpc/swd.read -d "{\"addr\":$1, \"size\": $2}" \| jq -r .data \| xxd -r -p \| hexdump -C ; }
	hex() { node -p "($*).toString(16)"; }
Example	Type	Description
H	Type	F: mainstream, L: low power, H: high performance, W: wireless
7	Core	0: M0, 1: M3, 2: M3, 3: M4, 4: M4, 7: M7
23	Line	speed, peripherals, silicon process, …
Z	Pin count	F: 20, G: 28, K: 32, T: 36, S: 44, C: 48, R: 64,66, V: 100, Z: 144, I: 176
	// Copyright (c) Cesanta Software Limited
	// All rights reserved
	// SPDX-License-Identifier: MIT

	// Usage example (Arduino):
	// char buf[100];
	// struct slip slip = {.buf = buf, .size = sizeof(buf) - 1};
	// ...
	// unsigned char c = Serial.read();
	// size_t len = slip_recv(c, &slip);
	#include <sttdef.h>

	// Single producer, single consumer non-blocking queue
	//
	// Producer:
	// void *buf;
	// while (mg_queue_space(q, &buf, len) == 0) WAIT(); // Wait for free space
	// memcpy(buf, data, len); // Copy data to the queue
	// mg_queue_add(q, len); // Advance q->head
	//