SW-SPI ATTiny13V Max3100

[Lucky (Gast)]

Hey zusammen,

Ich habe ein Projekt vor mir, mit dem Thema Energy Harvesting.
Dabei soll ich werte eines Sensors am PC ausgeben.
aber meine vorgeschlagen Teile seihen zu verschwenderisch. 
(kty81->atmega8l->max3232->PC).
Ich soll es mit einem ATtiny13V und SPI machen. Ich hoffe das, ich meine 
ersten Hürden Überwältigung habe mit AD-wanlder und software SPI.
Und Die übertragung wollte ich dann mit einem MAX3100 machen der kann ja 
SPI zu UART. Jetzt weiss ich nicht wie ich die configuration schreiben 
soll im Code.
Habt Ihr tipps bzw. hat jemand sowas schon mal gemacht?

#include<avr/io.h>
#include<avr/interrupt.h>
#include<util/delay.h>


//#define F_CDU 4000000UL
//DDRB
#define SOFT_SPI_MOSI_DDR  DDRB
#define SOFT_SPI_CLK_DDR  DDRB
#define SOFT_SPI_MISO_DDR  DDRB
//PORTB
#define SOFT_SPI_MOSI_PORT  PORTB
#define SOFT_SPI_CLK_PORT   PORTB

//PINB
#define SOFT_SPI_MISO_PIN   PB1
//BIT
#define SOFT_SPI_MOSI_BIT   PB0
#define SOFT_SPI_MISO_BIT   PB1
#define SOFT_SPI_CLK_BIT    PB2


void SOFT_SPI_init(void)
{
  // MOSI und CLK auf Ausgang setzen
  SOFT_SPI_MOSI_DDR |=(1<<SOFT_SPI_MOSI_BIT);
  SOFT_SPI_CLK_DDR  |=(1<<SOFT_SPI_CLK_BIT);

  // MOSI und CLK auf HIGH setzen
  SOFT_SPI_MOSI_PORT|=(1<<SOFT_SPI_MOSI_BIT);
  SOFT_SPI_CLK_PORT |=(1<<SOFT_SPI_CLK_BIT);

  // MISO auf Eingang setzen
  SOFT_SPI_MISO_DDR &=~(1<<SOFT_SPI_MISO_BIT);
}

void ADC_INIT(void)
{

  ADCSRA = (1<<ADEN)|(1<<ADATE)|(1<<ADIE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //PB5 AD-Channel
  ADCSRA |= (1<<ADSC);
}

unsigned char SOFT_SPI_WriteRead(unsigned char dataout)
{
  uint8_t datain=0;
  //das Byte wird Bitweise nacheinander Gesendet MSB zuerst
  for (uint8_t a=8; a>0; a--){                
      datain<<=1;                      //Schieben um das Richtige Bit zusetzen
      SOFT_SPI_CLK_PORT &=~(1<<SOFT_SPI_CLK_BIT);     // Clock auf LOW
                                
      if (dataout & 0x80){                //Ist Bit a in Byte gesetzt
        SOFT_SPI_MOSI_PORT |=(1<<SOFT_SPI_MOSI_BIT);   //Set Output High
      }
      else{
        SOFT_SPI_MOSI_PORT &=~(1<<SOFT_SPI_MOSI_BIT);   //Set Output Low
      }
      _delay_us(1);
      if (SOFT_SPI_MISO_PIN & (1<<SOFT_SPI_MISO_BIT))   //Lesen des Pegels 
        {
        datain |= 1;
        }

      _delay_us(1);
      SOFT_SPI_CLK_PORT |=(1<<SOFT_SPI_CLK_BIT);       // Clock auf High
      _delay_us(2);
      dataout<<=1;                     //Schiebe um nächstes Bit zusenden
    }

  return datain;
}



int main(void)
{
  ADC_INIT();
  SOFT_SPI_init();
  SOFT_SPI_WriteRead(ADCW);


  while(1)
  {
    
  }
  return 0;  

}

Ich wollte das Projekt später erweitern mit dem RFM12B, hat der tiny13 
genug speicher oder wirds da eng?

ich danke euch schon mal im voraus
MfG
Lucky

[Lucky (Gast)]

hat es noch keiner gemacht, wäre echt cool wenn einer ein beispiel 
hätte.

[Peter D. (peda)]

Niemand, der bei Verstand ist, macht sowas.
Mal mal den Schaltplan auf, dann weißt Du warum.

Nimm nen ATmega48, der ist außerdem deutlich billiger.
Oder nen ATtiny24 und mach die UART in Software.


Peter

[Lucky (Gast)]

Habe ich gemacht aber, irgendwie sehe ich da kein fehler.
MOSI -> DI
MISO -> DOUT
CLK -> SCLK
Kannst du mir da auf die sprünge helfen?

[Peter D. (peda)]

Nö, Du brauchst 5 Leitungen (Datenblatt S.23).
Und wieviel IOs bleiben dann vom ATtiny13 übrig?

Und der Preis des MAX3100 ist auch astronomisch.


Peter

[Lucky (Gast)]

klar der MAX3100 hat seinen preis, aber ich muss Ihn ja nicht kaufen. ;)
Und leider der Attiny13 und SPI wurden mir vorgeschrieben.

das man 5 Leitungen braucht habe ich ausser acht gelassen, weil ich 
eigentlich nur Daten senden will, deshalb ging davon aus das ich die 
anderen beiden weg lassen kann.

Ich habe einen anderen code gefunden und für mich passend zu geschrieben 
aber es kommt nichts bei rum, Ich weiss nicht wohin mit dem IRQ.

#include<avr/io.h>

//DDRB
#define SPI_MOSI_DDR  DDRB
#define SPI_CLK_DDR  DDRB
#define SPI_MISO_DDR  DDRB
#define SPI_SS_DDR  DDRB
//PORTB
#define SPI_MOSI_PORT  PORTB
#define SPI_CLK_PORT   PORTB
#define SPI_MISO_PORT   PORTB
#define SPI_SS_PORTB  PORTB
// PIN 
#define SPI_MOSI_PIN  PB0
#define SPI_MISO_PIN  PB1
#define SPI_CLK_PIN    PB2
#define  SPI_SS_PIN     PB3
//MAX3100 
#define MAX3100_WRITE_CONFIG  0xC000
#define MAX3100_WRITE_DATA    0x8000
 
void ADC_INIT(void)
{
ADCSRA = (1<<ADEN)|(1<<ADATE)|(1<<ADIE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); //PB5 AD-wandler |(1<<ADLAR)
ADCSRA |= (1<<ADSC);
}

void SPI_INIT(void)
{
  // MOSI, CLK und SS auf Ausgang setzen
  
  SPI_MOSI_DDR |=(1<<SPI_MOSI_PIN);
  SPI_CLK_DDR  |=(1<<SPI_CLK_PIN);
  SPI_SS_DDR   |=(1<<SPI_SS_PIN);
  
  // MOSI, CLK und SS auf HIGH setzen
  SPI_MOSI_PORT|=(1<<SPI_MOSI_PIN);
  SPI_CLK_PORT |=(1<<SPI_CLK_PIN);
  SPI_SS_PORTB |=(1<<SPI_SS_PIN);
 
 // MISO auf Eingang setzen
  SPI_MISO_DDR &=~(1<<SPI_MISO_PIN);
}

unsigned int SPI_Write_Word(unsigned int word)
{
unsigned char i;
unsigned int mask;
unsigned int temp;

SPI_SS_PORTB &= ~(1<<SPI_SS_PIN);  
mask = 0x8000;
temp = 0;

for(i=0;i<16;i++)
{
if(mask & word) SPI_MOSI_PORT|=(1<<SPI_MOSI_PIN); 
else SPI_MOSI_PORT&=~(1<<SPI_MOSI_PIN); 
if(SPI_MISO_PIN == 1) temp |= mask;
SPI_CLK_PORT |=(1<<SPI_CLK_PIN); 
SPI_CLK_PORT &=~(1<<SPI_CLK_PIN); 
mask >>= 1;
}

SPI_SS_PORTB |= (1<<SPI_SS_PIN); 
return(temp);
}

void MAX3100_Write_Config(unsigned int config)
{
SPI_Write_Word(config); 
}

void MAX3100_Write_Data(unsigned char byte)
{
unsigned int w;
w = (unsigned int)byte | MAX3100_WRITE_DATA ;//w = ADCW | define 0x8000
SPI_Write_Word(w);

while(!(w & 0x4000)); // wait for TX buffer empty
}

int main()
{
ADC_INIT();
SPI_INIT();
SPI_Write_Word();
MAX3100_Write_Config(MAX3100_WRITE_CONFIG | 0x040B); // 9600,N,8,1, Interrupt + FIFO 
MAX3100_Write_Data(ADCW);
while(1)
{}
return 0;
}

danke für die Tipps