Galvaniškai atskirto maitinimo šaltinio projektavimas DC 12V – DC 12V

Tikslas – aprūpinti maitinimo įtampa generatoriaus temperatūros matuoklį. Galvaniškai atskirtas todėl, kad generatoriuje indukuojasi didelės įtampos, be to atskitu atveju jis gali būti surištas su 220V tinklu per inverterį.

Schema:

Į Q6 bazę paduodamas signalas iš NE555 pagrindu sumontuoto generatoriaus. Jo schema ir satelitinių elementų reikšmių skaičiavimas parodytas sekančiame paveiksle:

Ir čia visas gražumas: generatorius generuoja – transformatorius netransformuoja.

Klausimas. Kodėl tranzistoriaus kolektoriuje impulso žemas lygis nepasiekia ‘Žemės’. Žr. 1 2 ir 3 taškų oscilogramas:

Pastaba: 3-čios oscilogramos vertikalios ašies vertė: 0,2V/cm(langelis). Pirmų dvejų, kaip parodyta rankenėlių foto. 2V/cm ir 5us/cm

Išėjime apkrovus 910Om varža gaunama 4V 5tampa. Galia: P=4*4/910=17.5mW. Pageidautina 1W galia. Transformatorius paimtas iš budinčio maitinimo dalies Codegen 300W ATX maitinimo bloke. Visos apvijos nuimtos, suvyniota 70-80 pirminė ir antrinė apvijos ~0,5mm laidu.

Kaip rodo 3-čia oscilograma tranzistorius komutuoja 1A srovę impulso metu. Prie 12V maitinimo ir  K=3,5/2,5 = 58% generatoriaus impulsų skverbties sunaudojamas galingumas=U*I*K=12*1*0.58=6.96W. Toks galingumas turėtų būti paduodamas į trafą. Išeinantis galingumas 17,5mW. naudingumo koeficientas 0,017/6,96=0.24% !!!!???

Ką daryti?

 

Temperatūros matavimas

Matuosime generatoriaus temperatūrą. Daviklis bus termopora, įmontuota pačiame generatoriuje. Pabandysime analoginį termoporos signalą konvertuoti į skaitmeninį.

Kaip visada geras Kam to reikia? Ir atsakymas: paprastų sprendimų mes neieškom. O tiksliau: pritrūkom analoginių įėjimų Arduino modulyje. Teks naudoti skaitmeninius. Yra chipas MAX31856: Precision Thermocouple to Digital Converter
with Linearization. Tarsi jus turi viską ko reikia. Lemonoje galima jį užsakyti, kaina 9 €. Paieškokim dar. gal rasim kažką iš kompiuterinio laužo. Neblogas pamokymas yra puslapyje: http://garagelab.com/profiles/blogs/tutorial-show-the-temperature-of-the-enviornment-with-the-arduino su LM35 puslaidininkiniu temperatūriniu davikliu, kurio kaina 1,59€

 

PWM dažnio padidinimo funkcija:

void setPwmFrequency(int pin, int divisor) {
byte mode;
if(pin == 5 || pin == 6 || pin == 9 || pin == 10) {
switch(divisor) {
case 1: mode = 0x01; break;
case 8: mode = 0x02; break;
case 64: mode = 0x03; break;
case 256: mode = 0x04; break;
case 1024: mode = 0x05; break;
default: return;
}
if(pin == 5 || pin == 6) {
TCCR0B = TCCR0B & 0b11111000 | mode;
} else {
TCCR1B = TCCR1B & 0b11111000 | mode;
}
} else if(pin == 3 || pin == 11) {
switch(divisor) {
case 1: mode = 0x01; break;
case 8: mode = 0x02; break;
case 32: mode = 0x03; break;
case 64: mode = 0x04; break;
case 128: mode = 0x05; break;
case 256: mode = 0x06; break;
case 1024: mode = 0x07; break;
default: return;
}
TCCR2B = TCCR2B & 0b11111000 | mode;
}
}

Automatinis modemo prijungimas po atsijungimo

Užsikrovus Raspbian OS paleidžiamas autostartuojantis /etc/rc.local failas, kuriame įrašyta wvdial komanda.
Dingus ryšiui inicijuojamas modemo perkrovimas. Praktika parodė, kad pakanka modemo maitinimo išjungimo-įjungimo. Suprojektuokime 3G modemo įtampos padavimą per elektroninį raktą, valdomą GPIO7 išvadu. Schema atrodytų sekančiai:

Parašykim programėlę GPIO7 išvado valdymui: 3gonoff.

#include <iostream>
#include <stdio.h>
#include <sstream> // for std::stringstream
using namespace std;
#include <string.h>        //used by string
#include <wiringPi.h>
int main(int argc, char *argv[]) {
cout << "Raspbery GPIO 7 porto valdymas: on/off\n";
wiringPiSetup ();
pinMode (7, OUTPUT);
if (argc>1) {
std::stringstream convert(argv[1]);
int myint;
if (!(convert >> myint))
myint = 0;
if (myint==1) {
cout << "įjungiama\n";
digitalWrite(7, HIGH);
} else if (myint==0) {
cout << "išjungiamas\n";
digitalWrite(7, LOW);
} else {
cout << "argumentas turi būti 0 arba 1. Pvz: './3gonoff 0'\n";
}
} else {
cout << "argumentas turi būti 0 arba 1. Pvz: './3gonoff 0'\n";
}
return 0;
}

Kompiliavimo komanda: „g++ 3gonoff.c -o 3gonoff.o -lwiringPi”

Komandinė eilutė: „./3gonoff 1” – reiškia įjungimo komandą, „./3gonoff 0” reiškia išjungimo komandą.

Išsijungia gana lėtai: per 1-3 sek. Matosi kaip gęsta mėlynas 3g modemo indikatorius

Ši programa paruošta, bet dar nenaudojama. Tikiuosi kitų sprendimų, siekiant užtikrinti nenutrūkstamą Ineto darbą.

Dinaminio DNS registravimas

Bernt Cristian Egeland komentaras http://uavmatrix.com/viewpost/2/62/116/0/PX4-PixHawk/Setting-Up-Raspberry-Pi-A+-and-USB-3G-Modem%C2%A0

netinka, kadangi no-ip.com abonentas nemokamas tik pirmą mėnesį, be to nurodyta konfigūracija neveikia o google nurodo į nekorektišką inadtn client debian paketą. Taigi inadyn pakeyas išinstaliuojamas. apt-get remove inadyn.
Next we will install DynDns software which allows us to use a dynamic name to connect our laptop to RPI when using cellular network.
This is not required if your cell operator gives you static ip adress, but normally they dont.
So instead of finding your cell IP adress every time, we use Dynamic andress of your choice.

There are many DynDns vendors, pick one.  Im using No-ip.
Create a account and a Host name.

Lets say for this tutorial your host (dns) are myairplane.no-ip.info
Install Inadyn software into RPI which will sync your IP against your dns.
Type this syntax

 

apt–get install inadyn

 

Then we need to change the config to match our account at No-Ip

/etc/inadyn.conf

If the file above do not exists, it will create one.

paste in the bellow lines and change your username and password to your needs. (same credentials to log on No-Ip site)
Type your DynDns adress as alias. ( for this tutorial we use myairplane.no-ip.info .
ina
If you are using dndns.org dont change the dyndns_system. If you e.g using no-ip.info, change the
dyndns_system to default@no-ip.com

username USERNAME

password PASSWORD

alias

dyndns_system dyndns@dyndns.org

background

update_period_sec 60

Then we need to add this to startup script, so we dont need to start inadyn manually.

Type this syntax, just before the exit 0.

vi /etc/rc.local

  1. add this line
  1. /usr/sbin/inadyn &

Reboot Rpi.

 

Vietoj dinaminio DNS naudosime kolegos Goga sukurtą skriptą, kurio funkcija periodiškai (kas 5min.) į VJserver DB įrašys IP adresą, kurį turi jėgainės kontroleris. Kodėl to reikia? ogi jėgainės kontroleris per USB 3G modemą gauna inetą su kintamu IP adresu. Skriptas užrašytas faile /etc/host2mysql faile. Jo esmė yra ifconfig komanda nuskaityti valdiklio IP adresą ir jį kartu su host identifikatoriumi, kuris šiuo atveju yra ‘vejas001’  įrašyti į nutolusią (šiuo atveju ‘defas.lt’) DB (šiuo atveju ‘VJserver’). Jo turinys:
#!/bin/bash
sudo ifconfig ppp0 |grep „inet” | awk -F „:” ‘{print $2}’| awk ‘{print „insert into hosts(host,IP) values(\x27vejas001\x27,\x27” $1 „\x27)” }’ |mysql -h defas.lt -uvejas -p********* VJserver

Periodiškai paleidinėsime šį skriptą, tad įrašome eilutę į CRONTAB’ą.

komanda crontab -e:

0,5,10,15,20,25,30,35,40,45,50,55 * * * * /etc/host2mysql >/dev/log/crontab.log 2>&1

Čia nurodytą skriptą paleidžiame kas 5 min.

VJserver DB lentelės hosts struktūra (nutolusiame serveryje):

DROP TABLE IF EXISTS `VJserver`.`hosts`;
CREATE TABLE  `VJserver`.`hosts` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`host` varchar(45) NOT NULL,
`IP` varchar(15) NOT NULL,
`ModDate` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=34 DEFAULT CHARSET=latin1;

 

USB GSM modemo instaliavimas

Tikslas – turėti internetą laukuose.
pirmą kartą įjungus USB GSM modemą š USB portą ‘lsusb’ komanda grąžina:
root@raspberrypi:~# lsusb

Bus 001 Device 006: ID 12d1:14fe Huawei Technologies Co., Ltd.

po vieno perinstaliavimo radau tokią reikšmę:

Bus 001 Device 006: ID 12d1:1c05 Huawei Technologies Co., Ltd. E173s 3G broadband stick (modem on)

Čia įrenginio id 12d1:14fe atpažįstama kaip diskinis kaupiklis. Pervesime į modemo režimą:
Įjungus įrenginį, matome, kad sistema detektuoja:

root@raspberrypi:/home/pi# lsusb

Bus 001 Device 006: ID 046d:c06c Logitech, Inc. Optical Mouse

Bus 001 Device 005: ID 12d1:1506 Huawei Technologies Co., Ltd. E398 LTE/UMTS/GSM Modem/Networkcard

Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter

Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp. LAN9500 Ethernet 10/100 Adapter / SMSC9512/9514 Hub

Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Kaip Huawei modemą.

ifconfig išveda naują tinklo sąsają:

wwan0     Link encap:Ethernet HWaddr 58:2c:80:13:92:63

inet addr:169.254.169.80 Bcast:169.254.255.255 Mask:255.255.0.0

inet6 addr: fe80::3d2:b0ae:25df:f0c5/64 Scope:Link

UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:0 errors:0 dropped:0 overruns:0 frame:0

TX packets:69 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:0 (0.0 B) TX bytes:13408 (13.0 KiB)

Ši sąsaja atsiranda po minkšto perkrovimo komanda ‘reboot’.

sujungimas įvyksta komanda ‘wvdial 3gconnect &’. Čia naudojamas konfigūracinis failas: /etc/wvdial.conf:

[Dialer Defaults]
Init1 = ATZ
Init2 = ATQ0 V1 E1 S0=0 &C1 &D2
Modem Type = Analog Modem
Baud = 9600
New PPPD = yes
Modem = /dev/ttyUSB0
ISDN = 0

[Dialer 3gconnect]
Init1 = ATZ
Init2 = AT+CPIN=0203
Init3 = AT+CGDCONT=1,”IP”,”Tele2″
;Init2 = ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0
;Init3 = AT+CGDCONT=1,”IP”,”internet”
Stupid Mode = 1
Modem Type = Analog Modem
ISDN = 0
Phone = *99#
Modem = /dev/gsmmodem
Username = { }
Password = { }
Baud = 460800

Gateway pakeitimas į USB stick:
route del default
route add default dev ppp0

Kaip ir veikia, tačiau po 20-30 ping operacijų modemas atsijungia ir sistema pakimba.
testuojam. Visų pirma modemą. Jame yra Omnitel Windows OS programinė įranga. Suinstaliuojam į NB, paleidžiam ping – viskas veikia. Bandau suinstaliuoti 3g modemą į kitą kompą, tik šį kartą su LINUX OS. Įdomu, kad pirmą kartą įdėjus modemą jį detektavo kaip 12D1:14xx. po perkrovimo to neberadau, liko 12d1:1506 – modemo režimas. Vadinasi nebereikia modeswitch programos?

Taip, nebereikia. Pakanka „wvdial 3gconnect &” komandinės eilutės. O pingas sustodavo dėl USB įrenginio atsijungimo dėl nepakankamo USB maitinimo. Pajungus atskirais 4 laidais USB įrenginį, kuriam maitinimas paduodamas iš maitinimo šaltinio gautas 18 val ištisas ping’avimas 18 val. bėgyje. Viso supinginta 57000 paketų. Šią komandą įdedu į /etc/rc.local failą su „sleep 100” su 100 sekundžių delsa.
Visgi dėl atsitiktinio modemo atsijungimo sukurkime crontab komandą, kuri kas 15min. pabandys atnaujinti ryšį. Jeigu 3g ryšys bus veikiantis, tai tiesiog gausime pranešimą, kad USBmodemas yra užimtas. Taigi komanda 

crontab -e

įterpkime eilutę: 

15 0 * * * /etc/host2mysql >>/var/log/crontab.log

kuri suveikia kas 15 min..

* * * * * komanda vykdymui
| | | | +—– savaitės diena (0 – 6) (Sekmadienis=0)
| | | +——- mėnuo (1 – 12)
| | +——— mėnesio diena (1 – 31)
| +———– valanda (0 – 23)
+————- minutė (0 – 59)
* reiškia bet kurį
Crontabo darbo logą įrašysime į failą:

Gar vienas pastebėjimas: po maždaug 8 val. darbo, modemas tarsi atsijungia: lsusb mato modemą, ls /dev/gsmmodem irgi yra. Crontab.log faile įdomybės: gaunama klaida inicializuojant SIM kortelę: Sending AT+CPIN=xxxx (čia xxxx PIN’as) gaunama klaida +CME ERROR: 3 / Bad Init String.Ši klaida reiškia ‘Operation not allowed’. Klaidos pavyko išvengti /etc/wvdial.conf faile užkomentavus Init1 eilutę ir PIN operaciją iškėlus į atskirą sekciją (TY: pschyska):

[Dialer pin]
Init3 = AT+CMEE=1
Init4 = AT+CPIN=xxxx

[Dialer checkpin]
Init3 = AT+CPIN?

Vėjo daviklio emuliatorius

Kad nereikėtų laikyti prijungto vėjo greičio daviklio, sukursime jo emuliatorių. Idėja atrodo sekančiai: Raspberry (toliau Rpi) parašysime programą, kuri generuos meandro formos impulsą ir jį paduosime į Arduino vieną iš skaitmeninių įėjimų.

Dar kartą peržiūrėkime Rpi GPIO išvadus ir jų paskirtį. Žemiau informacija iš: http://raspi.tv/2013/rpi-gpio-basics-4-setting-up-rpi-gpio-numbering-systems-and-inputs

rev2-gpio-bold-173x300

  • raudonai pažymėti yra +3V3 bei +5V maitinimo kontaktai
  • juodai pažymėti yra „Žemės” kontaktai
  • geltonai pažymėti yra bendro naudojimo  I/O portai (beje, 18 yra PWM-inis).

Likusieji taip pat gali būti naudojami kaip  GPIO portai, tačiau jie yra priskirti funkcijoms. Jei užtenka 8 portų rekomenduotina naudoti pažymėtus geltonai išvengiant galimų konfliktavimų su kitomis sąsajomis. Trumpai kitų sąsajų išvadai…

  • žaliai/pilkas – i2c sąsaja
  • šviesiai pilki – UART (nuosekli sąsaja)
  • oranžiniai– SPI (Serial Peripheral Interface) sąsaja.

Tarkime, pasirinkome GPIO4 7 išvadą kaip impulsų generatoriaus išėjimą. Jį reikia sujungti su Arduino skaitmeniniu įėjimu, kuris, tarkim bus ~3 (čia tildė nurodo, kad tai bus PVM ‘inis išvadas, matuosime impulso ilgį dažnio nustatymui: Hz=1/sek). Čia tinkama bendra Rpi-Arduino sujungimų nuotrauka.

Meandro generavimo programos pagrindu naudosime (TY joan) http://raspberrypi.stackexchange.com/questions/19765/rpi-gpio-as-a-high-speed-square-wave-generator parašytą C kalba. Pavadinsime meandras.c:

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <string.h>
#include <pigpio.h>
#define GPIO 4
#define ON   10
#define OFF  10
static int gpio = GPIO;
static int on   = ON;
static int off  = OFF;
gpioPulse_t pulse[2];
void fatal(char *fmt, ...){
   char buf[256];
   va_list ap;
   va_start(ap, fmt);
   vsnprintf(buf, sizeof(buf), fmt, ap);
   va_end(ap);
   fprintf(stderr, "%s\n", buf);
   exit(EXIT_FAILURE);
}
void usage(){
   fprintf(stderr, "\n" \
      "Usage: sudo ./square [OPTION] ...\n" \
      "   -f value, off micros, 1- (%d)\n" \
      "   -g value, gpio, 0-31     (%d)\n" \
      "   -n value, on micros, 1-  (%d)\n" \
      "EXAMPLE\n" \
      "sudo ./square -g 23\n" \
      "  Generate square wave on gpio 23.\n" \
   "\n", OFF, GPIO, ON);
}
static void initOpts(int argc, char *argv[]) {
   int i, opt;
   while ((opt = getopt(argc, argv, "f:g:n:")) != -1) {
      i = -1;
      switch (opt) {
         case 'f':
            i = atoi(optarg);
            if (i >= 1) off = i;
            else fatal("invalid -f option (%d)", i);
            break;
         case 'g':
            i = atoi(optarg);
            if ((i >= 1) && (i <= 31)) gpio = i;
            else fatal("invalid -g option (%d)", i);
            break;
         case 'n':
            i = atoi(optarg);
            if (i >= 1) on = i;
            else fatal("invalid -n option (%d)", i);
            break;
         default: /* '?' */
            usage();
            exit(EXIT_FAILURE);
        }
    }
}
int main(int argc, char *argv[]) {
   int wid;
   initOpts(argc, argv);
   printf("gpio #%d, on %dus, off %dus\n", gpio, on, off);
   if (gpioInitialise()<0) return -1;
   gpioSetMode(gpio, PI_OUTPUT);
   pulse[0].gpioOn = (1<<gpio);
   pulse[0].gpioOff = 0;
   pulse[0].usDelay = on;
   pulse[1].gpioOn = 0;
   pulse[1].gpioOff = (1<<gpio);
   pulse[1].usDelay = off;
   gpioWaveClear();
   gpioWaveAddGeneric(2, pulse);
   wid = gpioWaveCreate();
   if (wid >= 0) {
      gpioWaveTxSend(wid, PI_WAVE_MODE_REPEAT);
      while (1) sleep(1);
   }
   gpioTerminate();
}

Kompiliavimui papildomai naudojame pigpio biblioteką, taigi kompiliavimo eilutė pailgėja:

gcc -o meandras.o -L/usr/lib -lmysqlclient -lpigpio -I/usr/local/include -L/usr/local/lib -lwiringPi meandras.c

Paduodame iš Rpi 7 kontakto GPIO4 signalą į Arduino plokštės D3 kontaktą. Signalo apdorojimui pasirinkime iš http://www.benripley.com/diy/arduino/three-ways-to-read-a-pwm-signal-with-arduino/

straipsnyje aprašytų trijų būdų antrą, šiek tiek pakeičiame programos tekstą. Rezultatą saugome [17] ir [18] dat masyvo elementuose.

const int VejoPin=3;

volatile int pwm_value = 0;
volatile int prev_time = 0;

Setup{

attachInterrupt(digitalPinToInterrupt(VejoPin), rising, RISING);

}

void rising() {
attachInterrupt(digitalPinToInterrupt(VejoPin), falling, FALLING);
VejoGreitisx10=micros()-prev_time;
VejoGreitisx10=10000000/VejoGreitisx10;
dat[17]=lowByte(VejoGreitisx10); dat[18]=highByte(VejoGreitisx10);
prev_time = micros();
}
void falling() {
attachInterrupt(digitalPinToInterrupt(VejoPin), rising, RISING);
}

 

Liko dažnio keitimas nuo potenciometro, kuris bus pajungtas į Arduino A0 įėjimą, padėties. A0 reikšmės bus perduodamos per SPI sąsają. meandras programą integruosiu į pagrindinę programą. Bet tai jau rytoj.

Analoginių išvadų reikšmių užklausa iš rpi į Arduino per SPI sąsają ir patalpinimas į MYSQL

Kompiliavimo eilutė:

gcc -o spi2mysqlx100.o -L/usr/lib/test1 -lmysqlclient -I/usr/local/include -L/usr/local/lib -lwiringPi spi2mysqlx100.c

rpi c kodas: spi2mysql1kx.c

/*********************************************************
SPI_Hello_Arduino
    Configures an Raspberry Pi as an SPI master and demonstrates bidirectional communication with an
    Arduino Slave by 1000 times repeat request Arduino with AR_command string and ger response in result string
    Compile String: gcc -o spi2mysqlx100.o -L/usr/lib/test1 -lmysqlclient -I/usr/local/include -L/usr/local/lib -lwiringPi spi2mysqlx100.c
***********************************************************/
#include <mysql/mysql.h> //used by mysql
#include <stdlib.h>  //used by mysql
#include <stdio.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>  //used by string
/**********************************************************
Declare Global Variables
***********************************************************/
int spiTxRx(unsigned char txDat);
int fd;
unsigned char AR_command[] = {0x81, 0xA8, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC7};
unsigned char spi_bitsPerWord;
unsigned char spi_mode;
struct connection_details{char *server;char *user;char *password;char *database;};
MYSQL* mysql_connection_setup(struct connection_details mysql_details){// first of all create a mysql instance and initialize the variables within
 MYSQL *connection = mysql_init(NULL); // connect to the database with the details attached.
 if (!mysql_real_connect(connection,mysql_details.server, mysql_details.user, mysql_details.password, mysql_details.database, 0, NULL, 0)) {
  printf(„Conection error : %s\n”, mysql_error(connection));exit(1);
 }
 return connection;
}
MYSQL_RES* mysql_perform_query(MYSQL *connection, char *sql_query){
 if (mysql_query(connection, sql_query)) {// send the query to the database
  printf(„MySQL query error : %s\n”, mysql_error(connection));
  exit(1);
 }
 return mysql_use_result(connection);
}
struct connection_details mysqlD;
MYSQL *conn;    // the connection
MYSQL_RES *res;    // the results
MYSQL_ROW row;     // the results row (line by line)
/**********************************************************
Main
    Setup SPI
    Open file spidev0.0 (chip enable 0) for read/write access with the file descriptor „fd”
    Configure transfer speed (1MkHz)
***********************************************************/
int main (void){
    mysqlD.server = „localhost”;  // where the mysql database is
    mysqlD.user = „vejojegaines”;  // the root user of mysql
    mysqlD.password = „vejojegaines”;  // the password of the root user in mysql
    mysqlD.database = „vejojegaines”;  // the databse to pick
    conn = mysql_connection_setup(mysqlD); // connect to the mysql database
    int i, qilgis, j;
    int status_value = -1;
    unsigned char result[20];
    unsigned char buffH[1];
    unsigned char buffL[1];
    fd = open(„/dev/spidev0.0″, O_RDWR);
    unsigned int speed =1000000;
    ioctl (fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
    j=0;
    while (j<1000) {     //while (1) {
        unsigned char qu[255]=”insert into vejojegaines.spi values (\”\”,”;
        for (i=0; i<sizeof(AR_command); i++) {
            result[i] = spiTxRx(AR_command[i]);
            if (i>4 && i<20) {
                if (i%2==0) {
                    sprintf(buffL, „%02X”, result[i-1]);
                    sprintf(buffH, „%02X”, result[i]);
                    strcat(qu, „X'”);
                    strcat(qu, buffH);
                    strcat(qu, buffL);
                    strcat(qu, „‘,”);
                }
            }
        }
        strcat(qu, ” null);”);
        //printf(„%s\n”, qu);
        res=mysql_perform_query(conn, qu); // assign the results return to the MYSQL_RES pointer
        mysql_free_result(res);   //clean up the database result set
        j++;
    }
    exit(1);
}
/**********************************************************
spiTxRx
    Transmits one byte via the SPI device, and returns one byte as the result.
    Establishes a data structure, spi_ioc_transfer as defined by spidev.h and loads the various members to pass the data
    and configuration parameters to the SPI device via IOCTL
    Local variables txDat and rxDat are defined and passed by reference. 
***********************************************************/
int spiTxRx(unsigned char txDat){
    unsigned char rxDat;
    struct spi_ioc_transfer spi;
    memset (&spi, 0, sizeof (spi));
    spi.tx_buf        = (unsigned long)&txDat;
    spi.rx_buf        = (unsigned long)&rxDat;
    spi.len           = 1;
    ioctl (fd, SPI_IOC_MESSAGE(1), &spi);
    return rxDat;
}
void ToMySQL(char qu[]) {
 res=mysql_perform_query(conn, qu); // assign the results return to the MYSQL_RES pointer
 mysql_free_result(res);   //clean up the database result set
}

Arduino kodas: AnalogRead_on_rpi_request_using_spi

#include <SPI.h>
const int markeris = 13;
String msg=”deb:”;
byte buf[20];
int dat[]={0,11,22,33,0×55,0x66,0x77,0x88,0x99,0x00,0x19,0x28,0x37,0x46,0x55,0x64,0x73,0x82,0x91,0x00};
int checksumreal,komanda;
int komilgis=0;
int i=0;
boolean beginas=false;
boolean process_error=false;
volatile byte pos;
volatile boolean process_it;
void setup (void){
  Serial.begin (115200);         // debugging
  pinMode(markeris, OUTPUT);
  pinMode(MISO, OUTPUT);         // have to send on master in, *slave out*
  pinMode(8, OUTPUT);            // have to send on master in, *slave out*
  SPCR |= _BV(SPE);              // turn on SPI in slave mode, get ready for an interrupt
  pos = 0;                       // buffer empty
  process_it = false;
  SPI.attachInterrupt();         // now turn on interrupts
}
ISR (SPI_STC_vect){              // SPI interrupt routine
  digitalWrite(markeris, HIGH);
  byte c = SPDR;                 // grab byte from SPI Data Register
  if (c==0x81 and beginas==false) {//msg+=micros();msg+=”.”;
    beginas=true;checksumreal=0;komilgis=0;    //0X81 hex’E – PAKETO PIRMAS BAITAS
  }
  if (beginas==true) {
    buf[pos]=c;
    checksumreal+=c; if(checksumreal>255)checksumreal=checksumreal-256;
    switch (pos) {
      case 1:  komanda=c;
                break;
      case 2:  komilgis=c;
               break;
      default:  
               if (pos<komilgis+3 and pos>1) SPDR=dat[pos-2];
               if (pos==komilgis+3) {
                   if (checksumreal==0) {
                       process_it=true;
                       process_error=false;//msg+=micros();msg+=”.”;
                    } else {
                       process_error=true;
                   }
                   beginas=false;
               }
               break;
    } 
    if (pos < sizeof(buf)) pos++; else {pos=0;beginas=false; msg+=”buffer overflow”;}
  }
  digitalWrite(markeris, LOW);
}
void loop (void){
  int x;
  if (process_it) {
    pos = 0;
    process_it = false;
  }
  x=analogRead(A0); dat[0]=lowByte(x); dat[1]=highByte(x);
  x=analogRead(A1); dat[2]=lowByte(x); dat[3]=highByte(x);
  x=analogRead(A2); dat[4]=lowByte(x); dat[5]=highByte(x);
  x=analogRead(A3); dat[6]=lowByte(x); dat[6]=highByte(x);
  x=analogRead(A4); dat[8]=lowByte(x); dat[9]=highByte(x);
  x=analogRead(A5); dat[10]=lowByte(x); dat[11]=highByte(x);
  x=millis(); dat[12]=lowByte(x); dat[13]=highByte(x);
}

 

Programos komentarai:

Pusė reikšmių MySQL’e nulinės. Perjungus Arduino maitinimą – vėl gerai

Markeris – LED’as arduino plokštėje neveikia.