From c185c20a798d87ebe714531f4a94e78493e3bb7e Mon Sep 17 00:00:00 2001
From: zlaxy <zlaxyi@gmail.com>
Date: Sun, 23 Dec 2018 18:53:54 +0300
Subject: [PATCH] init

---
 salad/SCRBLUE.sh                         |   5 +
 salad/ch1off.sh                          |   4 +
 salad/ch1on.sh                           |   4 +
 salad/ch2off.sh                          |   4 +
 salad/ch2on.sh                           |   4 +
 salad/checkled.sh                        |  18 +
 salad/checkled2.sh                       |   2 +
 salad/chtemphum.sh                       |   7 +
 salad/dht22-pine64/Makefile              |   7 +
 salad/dht22-pine64/README.md             |  57 +++
 salad/dht22-pine64/c_gpio.c              | 439 +++++++++++++++++++++++
 salad/dht22-pine64/c_gpio.h              |  51 +++
 salad/dht22-pine64/dht22                 | Bin 0 -> 25040 bytes
 salad/dht22-pine64/dht22.c               | 190 ++++++++++
 salad/dht22-pine64/pine64-gpio-number.py |  20 ++
 salad/dht22-pine64/wiringPi.c            | 103 ++++++
 salad/dht22-pine64/wiringPi.h            |  19 +
 salad/gpioinit.sh                        |  33 ++
 salad/screenshot.sh                      |  17 +
 19 files changed, 984 insertions(+)
 create mode 100755 salad/SCRBLUE.sh
 create mode 100755 salad/ch1off.sh
 create mode 100755 salad/ch1on.sh
 create mode 100755 salad/ch2off.sh
 create mode 100755 salad/ch2on.sh
 create mode 100755 salad/checkled.sh
 create mode 100755 salad/checkled2.sh
 create mode 100755 salad/chtemphum.sh
 create mode 100644 salad/dht22-pine64/Makefile
 create mode 100644 salad/dht22-pine64/README.md
 create mode 100644 salad/dht22-pine64/c_gpio.c
 create mode 100644 salad/dht22-pine64/c_gpio.h
 create mode 100755 salad/dht22-pine64/dht22
 create mode 100644 salad/dht22-pine64/dht22.c
 create mode 100644 salad/dht22-pine64/pine64-gpio-number.py
 create mode 100644 salad/dht22-pine64/wiringPi.c
 create mode 100644 salad/dht22-pine64/wiringPi.h
 create mode 100755 salad/gpioinit.sh
 create mode 100755 salad/screenshot.sh

diff --git a/salad/SCRBLUE.sh b/salad/SCRBLUE.sh
new file mode 100755
index 0000000..5a1f5a2
--- /dev/null
+++ b/salad/SCRBLUE.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+# files and dirs for backup:
+SAVEDIR=/salad/screenshots/
+DATETIME=`date "+%Y-%m-%d-%H-%M-%S"`
+ffmpeg -rtsp_transport tcp -i 'rtsp://ip.of.web.cam/user=admin&password=&channel=1&stream=0.sdp' -f image2 -vframes 1 -pix_fmt yuvj420p ${SAVEDIR}${DATETIME}.jpeg
diff --git a/salad/ch1off.sh b/salad/ch1off.sh
new file mode 100755
index 0000000..7b511bb
--- /dev/null
+++ b/salad/ch1off.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+# channel 1 off
+echo 1 >/sys/class/gpio/gpio36/value
+
diff --git a/salad/ch1on.sh b/salad/ch1on.sh
new file mode 100755
index 0000000..b6e822c
--- /dev/null
+++ b/salad/ch1on.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+# channel 1 on
+echo 0 >/sys/class/gpio/gpio36/value
+
diff --git a/salad/ch2off.sh b/salad/ch2off.sh
new file mode 100755
index 0000000..142fdce
--- /dev/null
+++ b/salad/ch2off.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+# channel 2 off
+echo 1 >/sys/class/gpio/gpio37/value
+
diff --git a/salad/ch2on.sh b/salad/ch2on.sh
new file mode 100755
index 0000000..50b55fc
--- /dev/null
+++ b/salad/ch2on.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+# channel 2 on
+echo 0 >/sys/class/gpio/gpio37/value
+
diff --git a/salad/checkled.sh b/salad/checkled.sh
new file mode 100755
index 0000000..e81d934
--- /dev/null
+++ b/salad/checkled.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+HOUR=`date "+%H"`
+CH1STATUS=`gpio read 21`
+cd /salad
+if [ "$HOUR" = "10" ] || [ "$HOUR" = "11" ] || [ "$HOUR" = "12" ] || [ "$HOUR" = "13" ]
+then
+    if [ "$CH1STATUS" = "0" ]; then
+        echo $CH1STATUS
+        sh ch1off.sh
+        echo off
+    fi
+else
+    if [ "$CH1STATUS" = "1" ]; then
+        echo $CH1STATUS
+        sh ch1on.sh
+        echo on
+    fi
+fi
diff --git a/salad/checkled2.sh b/salad/checkled2.sh
new file mode 100755
index 0000000..017034e
--- /dev/null
+++ b/salad/checkled2.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+sudo -u root sh /salad/checkled.sh
diff --git a/salad/chtemphum.sh b/salad/chtemphum.sh
new file mode 100755
index 0000000..34c4131
--- /dev/null
+++ b/salad/chtemphum.sh
@@ -0,0 +1,7 @@
+#!/bin/sh
+cd /salad
+DATETIME=`date "+%Y-%m-%d-%H-%M"`
+HUM=`dht22 -p 38 -s hum`
+sleep 1
+TEMP=`dht22 -p 38 -s temp`
+echo "$DATETIME HUM = $HUM TEMP = $TEMP" >> SALAD_log.txt
diff --git a/salad/dht22-pine64/Makefile b/salad/dht22-pine64/Makefile
new file mode 100644
index 0000000..6282dec
--- /dev/null
+++ b/salad/dht22-pine64/Makefile
@@ -0,0 +1,7 @@
+dht22: *.c
+		g++ -fpermissive -Wno-write-strings -o dht22 *.c
+
+install: dht22
+		sudo cp dht22 /usr/local/bin/
+		sudo chown root /usr/local/bin/dht22
+		sudo chmod u+s /usr/local/bin/dht22
diff --git a/salad/dht22-pine64/README.md b/salad/dht22-pine64/README.md
new file mode 100644
index 0000000..e912381
--- /dev/null
+++ b/salad/dht22-pine64/README.md
@@ -0,0 +1,57 @@
+## DHT11/22 for Pine A64
+
+This is simple C application that reads DHT11/22 sensor using one wire protocol.
+
+### Compile
+
+Compile directly on Pine A64.
+
+```bash
+apt-get install build-essential
+make
+sudo make install
+```
+
+### Use it
+
+Find a PINE GPIO number: http://joey.hazlett.us/pine64/pine64_pins.html
+
+Execute in terminal:
+
+```bash
+dht22 -p <pin-number> -d 1000
+```
+
+It will read DHT connected on <pin-number> value every 1000ms continuously.
+
+### Read specific value
+
+```bash
+dht22 -p <pin-number> -s hum
+dht22 -p <pin-number> -s temp
+```
+
+### Use with Home-Assistant
+
+Add this to your configuration file:
+
+```
+sensor:
+- platform: command_line
+  name: office_room
+  unit_of_measurement: "°C"
+  command: "dht22 -r 10 -s temp -p 71"
+- platform: command_line
+  name: office_room
+  unit_of_measurement: "humidity"
+  command: "dht22 -r 10 -s hum -p 71"
+```
+
+### Dependencies
+
+For controlling the GPIO's I used this RPi.GPIO-PineA64:
+https://github.com/swkim01/RPi.GPIO-PineA64/blob/master/source/c_gpio.c
+
+## Author
+
+Kamil Trzciński, ayufan@ayufan.eu
diff --git a/salad/dht22-pine64/c_gpio.c b/salad/dht22-pine64/c_gpio.c
new file mode 100644
index 0000000..d933ba9
--- /dev/null
+++ b/salad/dht22-pine64/c_gpio.c
@@ -0,0 +1,439 @@
+/*
+Copyright (c) 2012-2015 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <string.h>
+#include "c_gpio.h"
+
+#define BCM2708_PERI_BASE_DEFAULT   0x20000000
+#define BCM2709_PERI_BASE_DEFAULT   0x3f000000
+#define GPIO_BASE_OFFSET            0x200000
+#define FSEL_OFFSET                 0   // 0x0000
+#define SET_OFFSET                  7   // 0x001c / 4
+#define CLR_OFFSET                  10  // 0x0028 / 4
+#define PINLEVEL_OFFSET             13  // 0x0034 / 4
+#define EVENT_DETECT_OFFSET         16  // 0x0040 / 4
+#define RISING_ED_OFFSET            19  // 0x004c / 4
+#define FALLING_ED_OFFSET           22  // 0x0058 / 4
+#define HIGH_DETECT_OFFSET          25  // 0x0064 / 4
+#define LOW_DETECT_OFFSET           28  // 0x0070 / 4
+#define PULLUPDN_OFFSET             37  // 0x0094 / 4
+#define PULLUPDNCLK_OFFSET          38  // 0x0098 / 4
+
+#define PAGE_SIZE  (4*1024)
+#define BLOCK_SIZE (4*1024)
+
+//
+// For Pine A64/A64+ Board
+//
+#define PINEA64_GPIO_MASK	(0xFFFFFF80)
+#define SUNXI_GPIO_BASE		0x01C20000
+#define SUNXI_GPIO_REG_OFFSET   0x800
+#define PINEA64_GPIO_BASE	(SUNXI_GPIO_BASE + SUNXI_GPIO_REG_OFFSET)
+#define SUNXI_CFG_OFFSET	0x00
+#define SUNXI_DATA_OFFSET	0x10
+#define SUNXI_PUD_OFFSET	0x1C
+#define SUNXI_BANK_SIZE		0x24
+
+#define MAP_SIZE        (4096*2)
+#define MAP_MASK        (MAP_SIZE - 1)
+
+typedef struct sunxi_gpio {
+    unsigned int CFG[4];
+    unsigned int DAT;
+    unsigned int DRV[2];
+    unsigned int PULL[2];
+} sunxi_gpio_t;
+
+/* gpio interrupt control */
+typedef struct sunxi_gpio_int {
+    unsigned int CFG[3];
+    unsigned int CTL;
+    unsigned int STA;
+    unsigned int DEB;
+} sunxi_gpio_int_t;
+
+typedef struct sunxi_gpio_reg {
+    struct sunxi_gpio gpio_bank[9];
+    unsigned char res[0xbc];
+    struct sunxi_gpio_int gpio_int;
+} sunxi_gpio_reg_t;
+
+#define GPIO_BANK(pin)  ((pin) >> 5)
+#define GPIO_NUM(pin)   ((pin) & 0x1F)
+
+#define GPIO_CFG_INDEX(pin)     (((pin) & 0x1F) >> 3)
+#define GPIO_CFG_OFFSET(pin)    ((((pin) & 0x1F) & 0x7) << 2)
+
+#define GPIO_PUL_INDEX(pin)     (((pin) & 0x1F )>> 4)
+#define GPIO_PUL_OFFSET(pin)    (((pin) & 0x0F) << 1)
+
+int pinea64_found = 1;
+
+static volatile uint32_t *pio_map;
+// end of Pine A64/A64+
+
+static volatile uint32_t *gpio_map;
+
+void short_wait(void)
+{
+    int i;
+
+    for (i=0; i<150; i++) {    // wait 150 cycles
+        asm volatile("nop");
+    }
+}
+
+int setup(void)
+{
+    int mem_fd;
+    uint8_t *gpio_mem;
+    uint32_t peri_base;
+    uint32_t gpio_base;
+    unsigned char buf[4];
+    FILE *fp;
+    char buffer[1024];
+    char hardware[1024];
+    int found = 0;
+
+pinea64_found = 1;
+
+  if ( !pinea64_found )  {
+    // try /dev/gpiomem first - this does not require root privs
+    if ((mem_fd = open("/dev/gpiomem", O_RDWR|O_SYNC)) > 0)
+    {
+        gpio_map = (uint32_t *)mmap(NULL, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, mem_fd, 0);
+        if ((uint32_t)gpio_map < 0) {
+            return SETUP_MMAP_FAIL;
+        } else {
+            return SETUP_OK;
+        }
+    }
+
+    // revert to /dev/mem method - requires root
+
+    // determine peri_base
+    if ((fp = fopen("/proc/device-tree/soc/ranges", "rb")) != NULL) {
+        // get peri base from device tree
+        fseek(fp, 4, SEEK_SET);
+        if (fread(buf, 1, sizeof buf, fp) == sizeof buf) {
+            peri_base = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3] << 0;
+        }
+        fclose(fp);
+    } else {
+        // guess peri base based on /proc/cpuinfo hardware field
+        if ((fp = fopen("/proc/cpuinfo", "r")) == NULL)
+            return SETUP_CPUINFO_FAIL;
+
+        while(!feof(fp) && !found) {
+            fgets(buffer, sizeof(buffer), fp);
+            sscanf(buffer, "Hardware	: %s", hardware);
+            if (strcmp(hardware, "BCM2708") == 0 || strcmp(hardware, "BCM2835") == 0) {
+                // pi 1 hardware
+                peri_base = BCM2708_PERI_BASE_DEFAULT;
+                found = 1;
+            } else if (strcmp(hardware, "BCM2709") == 0 || strcmp(hardware, "BCM2836") == 0) {
+                // pi 2 hardware
+                peri_base = BCM2709_PERI_BASE_DEFAULT;
+                found = 1;
+            }
+        }
+        fclose(fp);
+        if (!found)
+            return SETUP_NOT_RPI_FAIL;
+    }
+
+    gpio_base = peri_base + GPIO_BASE_OFFSET;
+  }
+
+    // mmap the GPIO memory registers
+    if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0)
+        return SETUP_DEVMEM_FAIL;
+
+    if ((gpio_mem = malloc(BLOCK_SIZE + (PAGE_SIZE-1))) == NULL)
+        return SETUP_MALLOC_FAIL;
+
+    if ((uint32_t)gpio_mem % PAGE_SIZE)
+        gpio_mem += PAGE_SIZE - ((uint32_t)gpio_mem % PAGE_SIZE);
+
+  if ( pinea64_found )  {
+    gpio_map = (uint32_t *)mmap( (caddr_t)gpio_mem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, mem_fd, SUNXI_GPIO_BASE);
+    pio_map = gpio_map + (SUNXI_GPIO_REG_OFFSET>>2);
+  } else {
+    gpio_map = (uint32_t *)mmap( (void *)gpio_mem, BLOCK_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, mem_fd, gpio_base);
+  }
+
+    if ((uint32_t)gpio_map < 0)
+        return SETUP_MMAP_FAIL;
+
+    return SETUP_OK;
+}
+
+void clear_event_detect(int gpio)
+{
+  if ( !pinea64_found )  {
+    int offset = EVENT_DETECT_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    *(gpio_map+offset) |= (1 << shift);
+    short_wait();
+    *(gpio_map+offset) = 0;
+  }
+}
+
+int eventdetected(int gpio)
+{
+  if ( !pinea64_found )  {
+    int offset, value, bit;
+
+    offset = EVENT_DETECT_OFFSET + (gpio/32);
+    bit = (1 << (gpio%32));
+    value = *(gpio_map+offset) & bit;
+    if (value)
+        clear_event_detect(gpio);
+    return value;
+  }
+}
+
+void set_rising_event(int gpio, int enable)
+{
+  if ( !pinea64_found )  {
+    int offset = RISING_ED_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable)
+        *(gpio_map+offset) |= 1 << shift;
+    else
+        *(gpio_map+offset) &= ~(1 << shift);
+    clear_event_detect(gpio);
+  }
+}
+
+void set_falling_event(int gpio, int enable)
+{
+  if ( !pinea64_found )  {
+    int offset = FALLING_ED_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable) {
+        *(gpio_map+offset) |= (1 << shift);
+        *(gpio_map+offset) = (1 << shift);
+    } else {
+        *(gpio_map+offset) &= ~(1 << shift);
+    }
+    clear_event_detect(gpio);
+  }
+}
+
+void set_high_event(int gpio, int enable)
+{
+  if ( !pinea64_found )  {
+    int offset = HIGH_DETECT_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable)
+        *(gpio_map+offset) |= (1 << shift);
+    else
+        *(gpio_map+offset) &= ~(1 << shift);
+    clear_event_detect(gpio);
+  }
+}
+
+void set_low_event(int gpio, int enable)
+{
+  if ( !pinea64_found )  {
+    int offset = LOW_DETECT_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (enable)
+        *(gpio_map+offset) |= 1 << shift;
+    else
+        *(gpio_map+offset) &= ~(1 << shift);
+    clear_event_detect(gpio);
+  }
+}
+
+uint32_t sunxi_readl(volatile uint32_t *addr)
+{
+    uint32_t val = 0;
+    uint32_t mmap_base = (uint32_t)addr & (~MAP_MASK);
+    uint32_t mmap_seek = ((uint32_t)addr - mmap_base) >> 2;
+    val = *(gpio_map + mmap_seek);
+    return val;
+}
+
+void sunxi_writel(volatile uint32_t *addr, uint32_t val)
+{
+    uint32_t mmap_base = (uint32_t)addr & (~MAP_MASK);
+    uint32_t mmap_seek =( (uint32_t)addr - mmap_base) >> 2;
+    *(gpio_map + mmap_seek) = val;
+}
+
+void set_pullupdn(int gpio, int pud)
+{
+  if ( pinea64_found )  {
+    uint32_t regval = 0;
+    int bank = GPIO_BANK(gpio); //gpio >> 5
+    int index = GPIO_PUL_INDEX(gpio); // (gpio & 0x1f) >> 4
+    int offset = GPIO_PUL_OFFSET(gpio); // (gpio) & 0x0F) << 1
+
+    sunxi_gpio_t *pio = &((sunxi_gpio_reg_t *) pio_map)->gpio_bank[bank];
+
+    regval = *(&pio->PULL[0] + index);
+    regval &= ~(3 << offset);
+    regval |= pud << offset;
+    *(&pio->PULL[0] + index) = regval;
+  } else {
+    int clk_offset = PULLUPDNCLK_OFFSET + (gpio/32);
+    int shift = (gpio%32);
+
+    if (pud == PUD_DOWN)
+        *(gpio_map+PULLUPDN_OFFSET) = (*(gpio_map+PULLUPDN_OFFSET) & ~3) | PUD_DOWN;
+    else if (pud == PUD_UP)
+        *(gpio_map+PULLUPDN_OFFSET) = (*(gpio_map+PULLUPDN_OFFSET) & ~3) | PUD_UP;
+    else  // pud == PUD_OFF
+        *(gpio_map+PULLUPDN_OFFSET) &= ~3;
+
+    short_wait();
+    *(gpio_map+clk_offset) = 1 << shift;
+    short_wait();
+    *(gpio_map+PULLUPDN_OFFSET) &= ~3;
+    *(gpio_map+clk_offset) = 0;
+  }
+}
+
+void setup_gpio(int gpio, int direction, int pud)
+{
+  if ( pinea64_found )  {
+    uint32_t regval = 0;
+    int bank = GPIO_BANK(gpio); //gpio >> 5
+    int index = GPIO_CFG_INDEX(gpio); // (gpio & 0x1F) >> 3
+    int offset = GPIO_CFG_OFFSET(gpio); // ((gpio & 0x1F) & 0x7) << 2
+
+    sunxi_gpio_t *pio = &((sunxi_gpio_reg_t *) pio_map)->gpio_bank[bank];
+
+    set_pullupdn(gpio, pud);
+
+    regval = *(&pio->CFG[0] + index);
+    regval &= ~(0x7 << offset); // 0xf?
+    if (INPUT == direction) {
+        *(&pio->CFG[0] + index) = regval;
+    } else if (OUTPUT == direction) {
+        regval |=  (1 << offset);
+        *(&pio->CFG[0] + index) = regval;
+    } else {
+        printf("line:%dgpio number error\n",__LINE__);
+    }
+  } else {
+    int offset = FSEL_OFFSET + (gpio/10);
+    int shift = (gpio%10)*3;
+
+    set_pullupdn(gpio, pud);
+    if (direction == OUTPUT)
+        *(gpio_map+offset) = (*(gpio_map+offset) & ~(7<<shift)) | (1<<shift);
+    else  // direction == INPUT
+        *(gpio_map+offset) = (*(gpio_map+offset) & ~(7<<shift));
+  }
+}
+
+// Contribution by Eric Ptak <trouch@trouch.com>
+int gpio_function(int gpio)
+{
+  if ( pinea64_found )  {
+    uint32_t regval = 0;
+    int bank = GPIO_BANK(gpio); //gpio >> 5
+    int index = GPIO_CFG_INDEX(gpio); // (gpio & 0x1F) >> 3
+    int offset = GPIO_CFG_OFFSET(gpio); // ((gpio & 0x1F) & 0x7) << 2
+
+    sunxi_gpio_t *pio = &((sunxi_gpio_reg_t *) pio_map)->gpio_bank[bank];
+
+    regval = *(&pio->CFG[0] + index);
+    regval >>= offset;
+    regval &= 7;
+    return regval; // 0=input, 1=output, 4=alt0
+  } else {
+    int offset = FSEL_OFFSET + (gpio/10);
+    int shift = (gpio%10)*3;
+    int value = *(gpio_map+offset);
+    value >>= shift;
+    value &= 7;
+    return value; // 0=input, 1=output, 4=alt0
+  }
+}
+
+void output_gpio(int gpio, int value)
+{
+  if ( pinea64_found )  {
+    int bank = GPIO_BANK(gpio); //gpio >> 5
+    int num = GPIO_NUM(gpio); // gpio & 0x1F
+
+    sunxi_gpio_t *pio = &((sunxi_gpio_reg_t *) pio_map)->gpio_bank[bank];
+
+    if (value == 0)
+        *(&pio->DAT) &= ~(1 << num);
+    else
+        *(&pio->DAT) |= (1 << num);
+  } else {
+    int offset, shift;
+
+    if (value) // value == HIGH
+        offset = SET_OFFSET + (gpio/32);
+    else       // value == LOW
+       offset = CLR_OFFSET + (gpio/32);
+
+    shift = (gpio%32);
+
+    *(gpio_map+offset) = 1 << shift;
+  }
+}
+
+int input_gpio(int gpio)
+{
+  if ( pinea64_found )  {
+    uint32_t regval = 0;
+    int bank = GPIO_BANK(gpio); //gpio >> 5
+    int num = GPIO_NUM(gpio); // gpio & 0x1F
+
+    sunxi_gpio_t *pio = &((sunxi_gpio_reg_t *) pio_map)->gpio_bank[bank];
+
+    regval = *(&pio->DAT);
+    regval = regval >> num;
+    regval &= 1;
+    return regval;
+  } else {
+   int offset, value, mask;
+
+   offset = PINLEVEL_OFFSET + (gpio/32);
+   mask = (1 << gpio%32);
+   value = *(gpio_map+offset) & mask;
+   return value;
+  }
+}
+
+void cleanup(void)
+{
+    munmap((void *)gpio_map, BLOCK_SIZE);
+}
diff --git a/salad/dht22-pine64/c_gpio.h b/salad/dht22-pine64/c_gpio.h
new file mode 100644
index 0000000..3c3433f
--- /dev/null
+++ b/salad/dht22-pine64/c_gpio.h
@@ -0,0 +1,51 @@
+/*
+Copyright (c) 2012-2015 Ben Croston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+int setup(void);
+void setup_gpio(int gpio, int direction, int pud);
+int gpio_function(int gpio);
+void output_gpio(int gpio, int value);
+int input_gpio(int gpio);
+void set_rising_event(int gpio, int enable);
+void set_falling_event(int gpio, int enable);
+void set_high_event(int gpio, int enable);
+void set_low_event(int gpio, int enable);
+int eventdetected(int gpio);
+void cleanup(void);
+
+#define SETUP_OK           0
+#define SETUP_DEVMEM_FAIL  1
+#define SETUP_MALLOC_FAIL  2
+#define SETUP_MMAP_FAIL    3
+#define SETUP_CPUINFO_FAIL 4
+#define SETUP_NOT_RPI_FAIL 5
+
+#define INPUT  1 // is really 0 for control register!
+#define OUTPUT 0 // is really 1 for control register!
+#define ALT0   4
+
+#define HIGH 1
+#define LOW  0
+
+#define PUD_OFF  0
+#define PUD_UP   1
+#define PUD_DOWN 2
diff --git a/salad/dht22-pine64/dht22 b/salad/dht22-pine64/dht22
new file mode 100755
index 0000000000000000000000000000000000000000..8d3fb81b6099c8c5cce0969dc4e96e7c9c73efd4
GIT binary patch
literal 25040
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

literal 0
HcmV?d00001

diff --git a/salad/dht22-pine64/dht22.c b/salad/dht22-pine64/dht22.c
new file mode 100644
index 0000000..588b50d
--- /dev/null
+++ b/salad/dht22-pine64/dht22.c
@@ -0,0 +1,190 @@
+#include "wiringPi.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/resource.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#define MAX_TIMINGS	  86
+
+int DHT_PIN = 0;
+
+int read_dht_data(float *h, float *t)
+{
+  uint8_t j = 0, i;
+  int data[5] = { 0, 0, 0, 0, 0 };
+
+  pinMode(DHT_PIN, OUTPUT);
+  digitalWrite(DHT_PIN, LOW);
+  delay(18);
+  digitalWrite(DHT_PIN, HIGH);
+  delayMicroseconds(10);
+
+  pinMode(DHT_PIN, INPUT);
+
+  uint8_t laststate	= HIGH;
+  unsigned int lasttime = micros();
+
+  for(i = 0; i < MAX_TIMINGS; i++) {
+    int state;
+    unsigned int current;
+
+    while (true) {
+      state = digitalRead(DHT_PIN);
+      current = micros();
+      if (current - lasttime > 200) {
+        goto finish;
+      }
+      if (laststate != state) {
+        break;
+      }
+    }
+
+    /* ignore first 3 transitions */
+    if ((i >= 4) && (i % 2 == 0)) {
+      /* shove each bit into the storage bytes */
+      data[j / 8] <<= 1;
+      if ((current - lasttime) > 60)
+      data[j / 8] |= 1;
+      j++;
+    }
+
+    laststate = state;
+    lasttime = current;
+  }
+
+  finish:
+
+  if (j < 40) {
+    fprintf(stderr, "Not enough bits: %d\n", j);
+    return -1;
+  }
+
+  if (data[4] != ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
+    fprintf(stderr, "Invalid CRC\n");
+    return -2;
+  }
+
+  if (h) {
+    *h = (float)((data[0] << 8) + data[1]) / 10;
+    if (*h > 100) {
+      *h = data[0];	// for DHT11
+    }
+  }
+
+  if (t) {
+    *t = (float)(((data[2] & 0x7F) << 8) + data[3]) / 10;
+    if (*t > 125) {
+      *t = data[2];	// for DHT11
+    }
+    if (data[2] & 0x80)	{
+      *t = -*t;
+    }
+  }
+  return 0;
+}
+
+void setprio() {
+  id_t pid = getpid();
+  int ret = setpriority(PRIO_PROCESS, pid, 10000);
+  if (ret < 0) {
+    fprintf(stderr, "Failed to set prio: %d\n", errno);
+  }
+}
+
+void usage(const char *cmd) {
+  fprintf(stderr, "Usage: %s [-d <delaymsec>] [-r <retry>] [-p <pin>] [-s all|hum|temp]\n", cmd);
+  exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+  int delaymsec = 0;
+  int retry = 2;
+  int whattoshow = 0;
+
+  while (true) {
+    switch (getopt(argc, argv, "d:r:p:s:")) {
+      case -1:
+      goto done;
+
+      case 'd':
+      delaymsec = atoi(optarg);
+      break;
+
+      case 'r':
+      retry = atoi(optarg);
+      break;
+
+      case 'p':
+      DHT_PIN = atoi(optarg);
+      break;
+
+      case 's':
+      if (!strcmp(optarg, "all")) {
+        whattoshow = 0;
+      } else if (!strcmp(optarg, "hum")) {
+        whattoshow = 1;
+      } else if (!strcmp(optarg, "temp")) {
+        whattoshow = 2;
+      } else {
+        usage(argv[0]);
+      }
+      break;
+
+      default: /* '?' */
+      usage(argv[0]);
+      break;
+    }
+  }
+
+  done:
+
+  if (DHT_PIN <= 0) {
+    fprintf(stderr, "Missing DHT PIN. Go to: http://joey.hazlett.us/pine64/pine64_pins.html\n");
+    usage(argv[0]);
+  }
+
+  if (wiringPiSetup()) {
+    fprintf(stderr, "Failed to configure GPIO\n");
+    usage(argv[0]);
+  }
+
+  setprio();
+
+  while (1) {
+    float h = 0, c = 0;
+
+    for(int i = 0; i <= retry; ++i) {
+      if(read_dht_data(&h, &c) == 0) {
+        switch(whattoshow) {
+          case 0:
+          printf("Humidity: %.1f %%\n", h);
+          printf("Temperature: %.1f *C\n", c);
+          break;
+
+          case 1:
+          printf("%.1f\n", h);
+          break;
+
+          case 2:
+          printf("%.1f\n", c);
+          break;
+        }
+
+
+        break;
+      }
+    }
+
+    if(delaymsec > 0) {
+      delay(delaymsec);
+    } else {
+      break;
+    }
+  }
+
+  return(0);
+}
diff --git a/salad/dht22-pine64/pine64-gpio-number.py b/salad/dht22-pine64/pine64-gpio-number.py
new file mode 100644
index 0000000..2c87f2d
--- /dev/null
+++ b/salad/dht22-pine64/pine64-gpio-number.py
@@ -0,0 +1,20 @@
+#!/usr/bin/python3
+
+import sys
+import string
+
+def convert(value):
+	value = value.upper()
+	alp = value[1]
+	idx = string.ascii_uppercase.index(alp)
+	num = int(value[2:], 10)
+	res = idx * 32 + num
+	return res
+
+if __name__ == "__main__":
+	args = sys.argv[1:]
+	if not args:
+		print("Usage: %s <pin>" % sys.argv[0])
+		sys.exit(1)
+
+	print("%d" % convert(args[0]))
\ No newline at end of file
diff --git a/salad/dht22-pine64/wiringPi.c b/salad/dht22-pine64/wiringPi.c
new file mode 100644
index 0000000..06167cf
--- /dev/null
+++ b/salad/dht22-pine64/wiringPi.c
@@ -0,0 +1,103 @@
+// License MIT
+// Compatibility layer done by Kamil Trzcinski <ayufan@ayufan.eu>
+
+#include "wiringPi.h"
+
+static uint64_t epochMilli, epochMicro;
+
+int wiringPiSetup()
+{
+  initialiseEpoch();
+  return setup();
+}
+
+int digitalRead(int gpio)
+{
+  return input_gpio(gpio);
+}
+
+void digitalWrite(int gpio, int value)
+{
+  output_gpio(gpio, value);
+}
+
+void pinMode(int gpio, int direction)
+{
+  setup_gpio(gpio, direction, PUD_UP);
+}
+
+//
+// The functions belowe are copied from wiringPi
+//
+
+void initialiseEpoch (void)
+{
+  struct timeval tv ;
+
+  gettimeofday (&tv, NULL) ;
+  epochMilli = (uint64_t)tv.tv_sec * (uint64_t)1000    + (uint64_t)(tv.tv_usec / 1000) ;
+  epochMicro = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)(tv.tv_usec) ;
+}
+
+void delayMicrosecondsHard (unsigned int howLong)
+{
+  struct timeval tNow, tLong, tEnd ;
+
+  gettimeofday (&tNow, NULL) ;
+  tLong.tv_sec  = howLong / 1000000 ;
+  tLong.tv_usec = howLong % 1000000 ;
+  timeradd (&tNow, &tLong, &tEnd) ;
+
+  while (timercmp (&tNow, &tEnd, <))
+    gettimeofday (&tNow, NULL) ;
+}
+
+void delayMicroseconds (unsigned int howLong)
+{
+  struct timespec sleeper ;
+  unsigned int uSecs = howLong % 1000000 ;
+  unsigned int wSecs = howLong / 1000000 ;
+
+  /**/ if (howLong ==   0)
+    return ;
+  else if (howLong  < 100)
+    delayMicrosecondsHard (howLong) ;
+  else
+  {
+    sleeper.tv_sec  = wSecs ;
+    sleeper.tv_nsec = (long)(uSecs * 1000L) ;
+    nanosleep (&sleeper, NULL) ;
+  }
+}
+
+void delay (unsigned int howLong)
+{
+  struct timespec sleeper, dummy ;
+
+  sleeper.tv_sec  = (time_t)(howLong / 1000) ;
+  sleeper.tv_nsec = (long)(howLong % 1000) * 1000000 ;
+
+  nanosleep (&sleeper, &dummy) ;
+}
+
+unsigned int millis (void)
+{
+  struct timeval tv ;
+  uint64_t now ;
+
+  gettimeofday (&tv, NULL) ;
+  now  = (uint64_t)tv.tv_sec * (uint64_t)1000 + (uint64_t)(tv.tv_usec / 1000) ;
+
+  return (uint32_t)(now - epochMilli) ;
+}
+
+unsigned int micros (void)
+{
+  struct timeval tv ;
+  uint64_t now ;
+
+  gettimeofday (&tv, NULL) ;
+  now  = (uint64_t)tv.tv_sec * (uint64_t)1000000 + (uint64_t)tv.tv_usec ;
+
+  return (uint32_t)(now - epochMicro) ;
+}
diff --git a/salad/dht22-pine64/wiringPi.h b/salad/dht22-pine64/wiringPi.h
new file mode 100644
index 0000000..f83b4ad
--- /dev/null
+++ b/salad/dht22-pine64/wiringPi.h
@@ -0,0 +1,19 @@
+// License MIT
+// Compatibility layer done by Kamil Trzcinski <ayufan@ayufan.eu>
+
+#include "c_gpio.h"
+#include <sys/time.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <time.h>
+
+int wiringPiSetup();
+int digitalRead(int gpio);
+void digitalWrite(int gpio, int value);
+void pinMode(int gpio, int direction);
+void initialiseEpoch (void);
+void delayMicrosecondsHard (unsigned int howLong);
+void delayMicroseconds (unsigned int howLong);
+void delay (unsigned int howLong);
+unsigned int millis (void);
+unsigned int micros (void);
diff --git a/salad/gpioinit.sh b/salad/gpioinit.sh
new file mode 100755
index 0000000..9559c65
--- /dev/null
+++ b/salad/gpioinit.sh
@@ -0,0 +1,33 @@
+#! /bin/sh
+
+ntpdate -q 0.rhel.pool.ntp.org
+
+echo 361 >/sys/class/gpio/export
+echo out >/sys/class/gpio/gpio361/direction
+echo 1 >/sys/class/gpio/gpio361/value
+
+echo 68 >/sys/class/gpio/export
+echo out >/sys/class/gpio/gpio68/direction
+echo 1 >/sys/class/gpio/gpio68/value
+
+echo 36 >/sys/class/gpio/export
+echo out >/sys/class/gpio/gpio36/direction
+echo 1 >/sys/class/gpio/gpio36/value
+
+echo 37 >/sys/class/gpio/export
+echo out >/sys/class/gpio/gpio37/direction
+echo 1 >/sys/class/gpio/gpio37/value
+
+echo 39 >/sys/class/gpio/export
+echo out >/sys/class/gpio/gpio39/direction
+echo 1 >/sys/class/gpio/gpio39/value
+
+echo 101 >/sys/class/gpio/export
+echo out >/sys/class/gpio/gpio101/direction
+echo 1 >/sys/class/gpio/gpio101/value
+
+echo 38 >/sys/class/gpio/export
+echo in >/sys/class/gpio/gpio38/direction
+
+sleep 120
+ntpdate -q 0.rhel.pool.ntp.org
diff --git a/salad/screenshot.sh b/salad/screenshot.sh
new file mode 100755
index 0000000..7262fd3
--- /dev/null
+++ b/salad/screenshot.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+# 10-15sec for photo
+SAVEDIR=/salad/screenshots/
+DATETIME=`date "+%Y-%m-%d-%H-%M-%S"`
+CH1STATUS=`gpio read 21`
+cd /salad
+./ch2on.sh
+sleep 0.5
+./ch1off.sh
+sleep 9
+ffmpeg -rtsp_transport tcp -i 'rtsp://ip.of.web.cam/user=admin&password=&channel=1&stream=0.sdp' -f image2 -vframes 1 -pix_fmt yuvj420p ${SAVEDIR}${DATETIME}.jpeg
+if [ "$CH1STATUS" = 0 ]
+then
+    ./ch1on.sh
+fi
+sleep 0.1
+./ch2off.sh