ATNEL tech-forum

Re: Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-11-10T18:35:49+01:00

Zrobiłem komunikację pomiędzy AVR a Arduino i działa, kod może prostacki ale jest. Mam jedynie problem z wysyłaniem danych między kilkoma urządzeniami. Mianowicie komunikacja działa pomiędzy:
1. Arduino - AVR
2. Arduino - LCD - karta SD

Ale gdy do LCD karty SD i Arduino podpinam AVR, wyświetlacz nie wyświetla nic brak wysyłania na terminal czegokolwiek.

Kod Arduino.

[syntax=c]#include
#include
#include "myassets.h"

#define pdPin 8

float angleValue1 = -1.0;
static void rotate_Center(float a, int CX, int CY);
int t = 1;
int obroty = 0;
int predkosc = 0;
int temp = 0;
int egt = 0;
float boost = 2.267;
float boost1 = 0;
int colej = 0;
int tolej = 0;
int paliwo = 0;
int mod1 = 0;
int mod2 = 0;
int mod3 = 0;

int i = 0;
int x = 0;
char odebrane;
int tab[25];
int zmienna = 0;
int zmienna1 = 0;
int zmienna2 = 0;

void setup()
{

Serial.begin(9600);
pinMode(pdPin, OUTPUT);
pinMode(9, OUTPUT);

digitalWrite(pdPin, HIGH);
delay(20);
digitalWrite(pdPin, LOW);
delay(20);
digitalWrite(pdPin, HIGH);
delay(20);

GD.begin();
LOAD_ASSETS ();

// GD.BitmapHandle(0);
// GD.cmd_loadimage(0, 0);
// GD.load("lcd3.png");
//
// GD.BitmapHandle(1);
// GD.cmd_loadimage(-1, 0);
// GD.load("Pn1.png");
//
// GD.BitmapHandle(2);
// GD.cmd_loadimage(-1, 0);
// GD.load("N0.png");
//
//
// GD.BitmapHandle(3);
// GD.cmd_loadimage(-1, 0);
// GD.load("N1.png");
//
// GD.BitmapHandle(4);
// GD.cmd_loadimage(-1, 0);
// GD.load("N2.png");
//
//
// GD.BitmapHandle(5);
// GD.cmd_loadimage(-1, 0);
// GD.load("N3.png");
//
//
// GD.BitmapHandle(6);
// GD.cmd_loadimage(-1, 0);
// GD.load("N4.png");
//
// GD.BitmapHandle(7);
// GD.cmd_loadimage(-1, 0);
// GD.load("N5.png");
//
// GD.BitmapHandle(8);
// GD.cmd_loadimage(-1, 0);
// GD.load("N6.png");
//
//// GD.BitmapHandle(9);
//// GD.cmd_loadimage(-1, 0);
//// GD.load("N7.png");

GD.ClearColorRGB(0xaaaaaa);
GD.End();

SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
SPI.begin(); // nowa linijka

}

void loop(){

// KOD DO POBIERANIA DANYCH Z AVR

int i;
int x = 0;

odbierz(i);

if ( odebrane == '#') {
while (odebrane != 'f') {
delay(2);
odbierz(i);
tab[x] = (odebrane - 48);
x++;

zmienna = tab[0];

for (int s = 1, d = 100; s < 4; s++ , d = d / 10) {

zmienna1 = (zmienna1 + (tab[s] * d));

}
zmienna1 = (zmienna1 - 100);

for (int o = 4, p = 1000; o < 8; o++ , p = p / 10) {

zmienna2 = (zmienna2 + (tab[o] * p));

}
zmienna2 = (zmienna2 - 1000);

Serial.print("Zmienna = ");
Serial.println(zmienna);

Serial.print("Zmienna1 = ");
Serial.println(zmienna1);

Serial.print("Zmienna2 = ");
Serial.println(zmienna2);

Serial.println();
}
}

// KONIEC KODU DO ODBIERANIA DANYCH

obroty = 0; //((analogRead(A0)) / 1.28);
predkosc = 0; //analogRead(A3);
temp = 0; //((analogRead(A2)) / 8.5);
egt = 0; // analogRead(A3);
angleValue1 = 0; //(((analogRead(A3)) / 4) - 135);
boost = analogRead(A0);
colej = 0; //((analogRead(A1)) / 8.5);
tolej = 0; //analogRead(A1);
paliwo = 0; //((analogRead(A3)) / 8.5);

delay(30);

mod1 = ( predkosc / 100);
mod2 = (( predkosc % 100) / 10);
mod3 = ( predkosc % 10);

GD.ClearColorRGB(0xaaaaaa);
GD.Clear();

// OBROTY

if (obroty <= 500) {
GD.ColorRGB(0x42ff00);
}
else if (obroty > 500 & obroty < 700) {
GD.ColorRGB(0xffcf07);
}
else if (obroty >= 700) {
GD.ColorRGB(0xfc0000);
}

GD.Begin(RECTS);
GD.Vertex2f(22 * 16, 35 * 16);
GD.Vertex2f(obroty * 16, 120 * 16);

// TEMPERATURA CIECZY

if (temp <= 90) {
GD.ColorRGB(0x42ff00);
}
else if (temp > 90 & temp < 100) {
GD.ColorRGB(0xffcf07);
}
else if (temp >= 100) {
GD.ColorRGB(0xfc0000);
}

GD.Begin(RECTS);
GD.Vertex2f(30 * 16, 204 * 16);
GD.Vertex2f((temp * 16) + (26 * 16), 233 * 16);

GD.ColorRGB(0x000000);
GD.cmd_number(88, 218, 24, OPT_CENTER, temp);
GD.cmd_text(117, 218, 24, OPT_CENTER, "C");

// EGT

if (egt <= 850) {
GD.ColorRGB(0x42ff00);
}
else if (egt > 850 & egt < 900) {
GD.ColorRGB(0xffcf07);
}
else if (egt >= 900) {
GD.ColorRGB(0xfc0000);
}

GD.Begin(RECTS);
GD.Vertex2f(30 * 16, 303 * 16);
GD.Vertex2f((((egt) / 8.5) * 16) + (26 * 16), 333 * 16);

GD.ColorRGB(0x000000);
GD.cmd_number(88, 318, 24, OPT_CENTER, egt);
GD.cmd_text(125, 318, 24, OPT_CENTER, "C");

// BOOST

if (boost <= 0) {
GD.ColorRGB(0x42ff00);
}
else if (boost > 0 & boost < 0.5) {
GD.ColorRGB(0xffcf07);
}
else if (boost >= 0.5) {
GD.ColorRGB(0xfc0000);
}

GD.Begin(RECTS);
GD.Vertex2f(30 * 16, 402 * 16);
GD.Vertex2f((((boost / 8.5)) * 16) + (26 * 16), 432 * 16);

GD.ColorRGB(0x000000);
GD.cmd_number(88, 416, 24, OPT_CENTER, ((boost)));
GD.cmd_text(117, 416, 24, OPT_CENTER, "KPa");

// C. Oleju

if ((colej / 28) <= 1) {
GD.ColorRGB(0xfc0000);
}
else if ((colej / 28) > 1 & (colej / 28) < 3) {
GD.ColorRGB(0xffcf07);
}
else if ((colej / 28) >= 3) {
GD.ColorRGB(0x42ff00);
}

GD.Begin(RECTS);
GD.Vertex2f(645 * 16, 203 * 16);
GD.Vertex2f((((colej)) * 16) + (645 * 16), 232 * 16);

GD.ColorRGB(0x000000);
GD.cmd_number(704, 217, 24, OPT_CENTER, (colej / 29));
GD.cmd_text(730, 217, 24, OPT_CENTER, "Bar");

// T. Oleju

if ((tolej / 8.5) <= 80) {
GD.ColorRGB(0x42ff00);
}
else if ((tolej / 8.5) > 80 & (tolej / 8.5) < 120) {
GD.ColorRGB(0xffcf07);
}
else if ((tolej / 8.5) >= 120) {
GD.ColorRGB(0xfc0000);
}

GD.Begin(RECTS);
GD.Vertex2f(645 * 16, 303 * 16);
GD.Vertex2f((((tolej / 8.5)) * 16) + (645 * 16), 332 * 16);

GD.ColorRGB(0x000000);
GD.cmd_number(704, 317, 24, OPT_CENTER, (tolej / 7));
GD.cmd_text(735, 317, 24, OPT_CENTER, "C");

// PALIWO

if (paliwo <= 10) {
GD.ColorRGB(0xfc0000);
}
else if (paliwo > 10 & paliwo < 50) {
GD.ColorRGB(0xffcf07);
}
else if (paliwo >= 50) {
GD.ColorRGB(0x42ff00);
}

GD.Begin(RECTS);
GD.Vertex2f(645 * 16, 403 * 16);
GD.Vertex2f(((paliwo) * 16) + (645 * 16), 432 * 16);

GD.ColorRGB(0x000000);
GD.cmd_number(704, 417, 24, OPT_CENTER, (paliwo));
GD.cmd_text(735, 417, 24, OPT_CENTER, "%");

// Prędkość

// Wczytanie grafiki PNG

GD.ColorRGB(0xffffff);
GD.Vertex2ii(0, 0, 10);
GD.cmd_number(755, 105, 30, OPT_CENTER, obroty * 10.3);

switch (mod1) {
case 0:
GD.Vertex2ii (307, 295, 0); // 0
break;

case 1:
GD.Vertex2ii (307, 295, 1); // 1
break;

case 2:
GD.Vertex2ii (307, 295, 2); // 2
break;

case 3:
GD.Vertex2ii (307, 295, 3); // 1
break;

case 4:
GD.Vertex2ii (307, 295, 4); // 2
break;
}

switch (mod2) {

case 0:
GD.Vertex2ii (367, 295, 0); // pic2
break;

case 1:
GD.Vertex2ii (367, 295, 1); // pic2
break;

case 2:
GD.Vertex2ii (367, 295, 2); // pic2
break;

case 3:
GD.Vertex2ii (367, 295, 3); // pic2
break;

case 4:
GD.Vertex2ii (367, 295, 4); // pic2
break;

case 5:
GD.Vertex2ii (367, 295, 5); // pic2
break;

case 6:
GD.Vertex2ii (367, 295, 6); // pic2
break;

case 7:
GD.Vertex2ii (367, 295, 7); // pic2
break;

case 8:
GD.Vertex2ii (367, 295, 8); // pic2
break;

case 9:
GD.Vertex2ii (367, 295, 9); // pic2
break;

}

switch (mod3) {

case 0:
GD.Vertex2ii (427, 295, 0); // pic3
break;

case 1:
GD.Vertex2ii (427, 295, 1); // pic3
break;

case 2:
GD.Vertex2ii (427, 295, 2); // pic3
break;

case 3:
GD.Vertex2ii (427, 295, 3); // pic3
break;

case 4:
GD.Vertex2ii (427, 295, 4); // pic3
break;

case 5:
GD.Vertex2ii (427, 295, 5); // pic3
break;

case 6:
GD.Vertex2ii (427, 295, 6); // pic3
break;

case 7:
GD.Vertex2ii (427, 295, 7); // pic3
break;

case 8:
GD.Vertex2ii (427, 295, 8); // pic3
break;

case 9:
GD.Vertex2ii (427, 295, 9); // pic3
break;

}

GD.Begin(BITMAPS);
rotate_Center(DEGREES(angleValue1), 156, 156);
GD.cmd_setmatrix();
GD.Vertex2ii(243, 172, 11); // wskazówka

GD.swap();

zmienna = 0; // nowa linijka
zmienna1 = 0; // nowa linijka
zmienna2 = 0; // nowa linijka

}

static void rotate_Center(float a, int CX, int CY)
{
GD.cmd_translate(F16(CX), F16(CY));
GD.cmd_rotate(a);
GD.cmd_translate(F16(-CX), F16(-CY));
}

// Funckcja odbierania znakow

void odbierz(unsigned int n) {
digitalWrite(9, LOW);
odebrane = SPI.transfer(n);
digitalWrite(9, HIGH);
}[/syntax]

Kod AVR

[syntax=c]#include
#include
#include
#define UART_BAUD 9600
#define __UBRR ((F_CPU+UART_BAUD*8UL) / (16UL*UART_BAUD)-1 ) // obliczeni

int c = 0;
int d = 0;
int e = 0;

while(1) {

PomiarC();
PomiarD();
PomiarE();

Wyslij_Ciag("pomiare = ");
Wyslij_CiagInt((e/105)); // Tutaj bieg od 0 do 9
Wyslij_Ciag("\n\r ");

Wyslij_Ciag("pomiarc = ");
Wyslij_CiagInt((c/4));// Tutaj predkosc od 0 do 300
Wyslij_Ciag("\n\r ");

Wyslij_Ciag("pomiard = ");
Wyslij_CiagInt((d*7)); // tutaj obroty od 0 do 7000
Wyslij_Ciag("\n\r ");

Wyslij_Ciag_SPI("#");
Wyslij_CiagInt_SPI((e/105));
Wyslij_CiagInt_SPI((c/4)+100);
Wyslij_CiagInt_SPI((d*7)+1000);
Wyslij_Ciag_SPI("f");

}
}

void spi_init_slave (void)
{
// set SCK, SS and MOSI as input
// DDRB &= ~(1 << PB5); // SCK WEJSCIE
// DDRB &= ~(1 << PB3); // MOSI WEJSCIE
DDRB &= ~(1 << PB2); // SS WEJSCIE
DDRB |= (1 << PB4); // MISO WYJSCIE
PORTB |= (1 << PB4); // pullup na MOSI

SPCR |= (1 << SPE); // wlacz SPI i ustaw jako Slave

}

void ADC_Inicjalizacja() {

ADCSRA = ( 1 << ADEN ) | ( 1 << ADPS0 ) | ( 1 << ADPS1 ) | ( 1 << ADPS2 ); // ADEN - W³¹czenie ADC, ADPS - Preskaler 128
//ADMUX = ( 1 << REFS1) | ( 1 << REFS0 ); // Napiêcie odniesienia 2,56V

DDRC &= ~(1 << PC0);
DDRC &= ~(1 << PC1);
DDRC &= ~(1 << PC2);

DDRB |= (1 << PB0);
}

uint16_t PomiarC() {

c = pomiar ( PC1 ) ;

if (c < 0) {

c = 0;

}

return c;

}

void Wyslij_Znak_SPI(char cData)
{
SPDR = cData;
while(!(SPSR & (1<}

void Wyslij_Ciag_SPI ( char * s )
{
while( *s ) Wyslij_Znak_SPI ( *s++ );
}

void Wyslij_CiagInt_SPI ( int val )
{
char buf[7];
itoa (val, buf, 10 );
Wyslij_Ciag_SPI ( buf );
}[/syntax]

Statystyki: Napisane przez Raqu — 10 lis 2020, o 18:35

Re: Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-10-15T11:36:19+01:00

Raqu napisał(a):

i nie pamiętam co gdzie jest.

Jak się wejdzie na czyjś kanał na YT to w szukajka wyszukuje po nazwach filmy z tego kanału zdaje się - tak można sobie pomagać jak coś

Statystyki: Napisane przez mirekk36 — 15 paź 2020, o 11:36

Re: Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-10-15T11:25:33+01:00

[quote="mirekk36"]Najpierw to warto zacząć od Bluebooka ....

https://atnel.pl/mikrokontrolery-avr-jezyk-c.html

a później kilka poradników wideo

Tak bluebook właśnie włożyli do Paczkomatu po pracy będę go odbierał. Co do filmów oglądałem ale dawno temu i nie pamiętam co gdzie jest.

Statystyki: Napisane przez Raqu — 15 paź 2020, o 11:25

Re: Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-10-15T10:32:02+01:00

Najpierw to warto zacząć od Bluebooka ....

https://atnel.pl/mikrokontrolery-avr-jezyk-c.html

a później kilka poradników wideo

iframe

Statystyki: Napisane przez mirekk36 — 15 paź 2020, o 10:32

Re: Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-10-15T07:26:40+01:00

Dane które przychodzą powinieneś pakować do bufora. Gdy przyjdzie znak końca ramki wtedy można podjąć decyzję do jakiej zmiennej przepisać zawartość bufora. (funkcja odwrotna do itoa czyli atoi). Cały proces jest opisany przez Mirka w tematach dotyczących buforów cyklicznych. Poszperaj. Co prawda dotyczyło to UARTA ale co za różnica czy to UART czy SPI. Obsługa bufora w przerwaniu będzie taka sama.

Statystyki: Napisane przez JarekB — 15 paź 2020, o 07:26

Re: Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-10-14T21:33:03+01:00

Próbowałem odbierać dane na przerwaniu ale nie chciało to chyba działać do końca pewnie robiłem coś źle. A na jakiej zasadzie przypisywać dane do różnych zmiennych ? Masz jakiś pomysł ?

Statystyki: Napisane przez Raqu — 14 paź 2020, o 21:33

Re: Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-10-14T19:43:47+01:00

A czy nie lepiej zrobić to na przerwaniu od SPI? W momencie kiedy nadejdą dane z Mastera do Slave wywołana zostanie procedura obsługi przerwania. W funkcji tej zostaną przypisane dane do zmiennej i gotowe.

Statystyki: Napisane przez Draxter32 — 14 paź 2020, o 19:43

Wysyłanie zmiennych z AVR do Arduino przez SPI.

2020-10-14T17:04:03+01:00

Witam,

Od kilku dni próbuję zrobić komunikację na SPI między AVR i Arduino. Wysyłanie pojedynczych znaków czy cyfr nie robi większego problemu. Natomiast nie mogę poradzić sobie z wysyłaniem kilku zmiennych które są obliczane w AVR i następnie mają być wysłane przez SPI do Arduino i tam na ich podstawie ma się wykonywać dalszy kod. Zrobiłem trochę ułomny kod którym wysyłam "#" i na jego podstawie odczytuję że jest to początek zmiennej 1, następnie wysyłam cyfry na monitor i wyświetla je poprawnie. Nie wiem tylko jak wpisać te liczby do zmiennej.

Tutaj kod Arduino:

[syntax=c]#include

int i = 0;
char odebrane;

void setup() {
Serial.begin(9600);
pinMode(10, OUTPUT);
SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
SPI.begin();
}

void odbierz(unsigned int n) {
digitalWrite(10, LOW);
odebrane = SPI.transfer(n);
}

void loop() {
int i;
odbierz(i);

if ( odebrane == '#') {

while ( odebrane != '&') {

if ( odebrane == '#') {
odbierz(i);
}
Serial.print(odebrane);
odbierz(i);
}
Serial.println();
}
}[/syntax]

Tutaj kod na AVR:

[syntax=c]#include
#include

int c=0;
int d=0;

void spi_init_master (void)
{
// set SCK, SS and MOSI as input
DDRB &= ~(1 << PB5); // SCK WEJSCIE
DDRB &= ~(1 << PB3); // MOSI WEJSCIE
DDRB &= ~(1 << PB2); // SS WEJSCIE
DDRB |= (1 << PB4); // MOSI WEJSCIE
PORTB |= (1 << PB4); // pullup na MOSI

SPCR |= (1 << SPE); // wlacz SPI

}

void Wyslij_Znak_SPI(char cData)
{
SPDR = cData;
while(!(SPSR & (1<}

void Wyslij_Ciag_SPI ( char * s )
{
while( *s ) Wyslij_Znak_SPI ( *s++ );
}

void Wyslij_CiagInt_SPI ( int val )
{
char buf[7];
itoa (val, buf, 10 );
Wyslij_Ciag_SPI ( buf );
}

int main(void)
{
spi_init_master(); // inicjalizacja spi

while(1) {

c = 5323;
d = 1234;

Wyslij_Ciag_SPI("#");
Wyslij_CiagInt_SPI(2455);
Wyslij_Ciag_SPI("\r \n");

Wyslij_Ciag_SPI("&");
Wyslij_CiagInt_SPI(d);
Wyslij_Ciag_SPI("\r \n");

}
}[/syntax]

Byłbym wdzięczny za pomoc bo już kończą mi się pomysły a nie mogę znaleźć nic co by mi pomogło.

Statystyki: Napisane przez Raqu — 14 paź 2020, o 17:04