Rose-Hulman Robotics Team

Changeset 584 for trunk/electronics

Show
Ignore:
Timestamp:
10/25/09 12:37:47 (2 years ago)
Author:
auchtemm
Message:

decoupled spi stuff from mcp code
{

Location:
trunk/electronics/avr/can-bridge
Files:
5 modified

Legend:

Unmodified
Added
Removed

  • trunk/electronics/avr/can-bridge/main.c

    r571 r584  
    155155}; 
    156156 
     157#define kCSLow    0 
     158#define kCSHigh   1 
     159 
     160void spi_mcp_cs(uint8_t state) 
     161{ 
     162   switch (state) { 
     163      case kCSLow: 
     164         PORTB &= ~(1 << PB0); 
     165         break; 
     166      case kCSHigh: 
     167         PORTB |= (1 << PB0); 
     168         break; 
     169   } 
     170} 
     171 
    157172int main(void) 
    158173{ 
     174        spi_context_t spi_ctxt; 
    159175        EICRA = 0; 
    160176        EIMSK |= 1; 
    … …  
    164180 
    165181   usart_init(19200); 
     182 
    166183        spi_init(); 
    167         mcp_init(handlers); 
     184        spi_ctxt.send = spi_send; 
     185        spi_ctxt.recv = spi_recv; 
     186        spi_ctxt.set_cs = spi_mcp_cs; 
     187 
     188 
     189        mcp_init(handlers, &spi_ctxt); 
    168190 
    169191        sei(); 

  • trunk/electronics/avr/can-bridge/mcp.c

    r571 r584  
    55#include <stdint.h> 
    66#include "usart.h" 
    7 #include "spi.h" 
    87#include "mcp.h" 
    98 
    … …  
    1817 
    1918static can_handler_t *handler_list = NULL; 
     19static spi_context_t *spi_ctxt = NULL; 
    2020 
    2121int can_handler(canmsg_t *msg, can_handler_t handler_list[]) 
    … …  
    4242} 
    4343 
    44  
    45 static void _setcs(uint8_t state) 
    46 { 
    47    switch (state) { 
    48       case kCSLow: 
    49          spi_cslow(CS); 
    50          break; 
    51       case kCSHigh: 
    52          spi_cshigh(CS); 
    53          break; 
    54    } 
    55  
    56 } 
     44//static void spi_ctxt->set_cs(uint8_t state) 
     45//{ 
     46//   switch (state) { 
     47//      case kCSLow: 
     48//         spi_cslow(CS); 
     49//         break; 
     50//      case kCSHigh: 
     51//         spi_cshigh(CS); 
     52//         break; 
     53//   } 
     54//} 
    5755 
    5856void mcp_set_mode(uint8_t mode) 
    … …  
    9189} 
    9290 
    93 void mcp_init(can_handler_t handlers[]) 
    94 { 
     91void mcp_init(const can_handler_t handlers[], spi_context_t *spi_context) 
     92{ 
     93 
     94   handler_list = (can_handler_t *)handlers; 
     95   spi_ctxt = spi_context; 
     96 
    9597   mcp_reset(); 
    96    handler_list = handlers; 
    9798 
    9899   mcp_set_mode(kModeConfig); 
    … …  
    110111void mcp_reset(void) 
    111112{ 
    112    _setcs(kCSLow); 
    113    spi_send(kCmdReset); 
    114    _setcs(kCSHigh); 
     113   spi_ctxt->set_cs(kCSLow); 
     114   spi_ctxt->send(kCmdReset); 
     115   spi_ctxt->set_cs(kCSHigh); 
    115116   _delay_ms(10); 
    116117} 
    … …  
    119120{ 
    120121 
    121    _setcs(kCSLow); 
    122    spi_send(kCmdWrite); 
    123    spi_send(addr); 
    124    spi_send(data); 
    125    _setcs(kCSHigh); 
     122   spi_ctxt->set_cs(kCSLow); 
     123   spi_ctxt->send(kCmdWrite); 
     124   spi_ctxt->send(addr); 
     125   spi_ctxt->send(data); 
     126   spi_ctxt->set_cs(kCSHigh); 
    126127} 
    127128 
    … …  
    130131   uint8_t i; 
    131132 
    132    _setcs(kCSLow); 
    133    spi_send(kCmdRead); 
    134    spi_send(addr); 
     133   spi_ctxt->set_cs(kCSLow); 
     134   spi_ctxt->send(kCmdRead); 
     135   spi_ctxt->send(addr); 
    135136 
    136137   for (i = 0; i < len; i++) 
    137       buf[i] = spi_recv(); 
    138  
    139    _setcs(kCSHigh); 
     138      buf[i] = spi_ctxt->recv(); 
     139 
     140   spi_ctxt->set_cs(kCSHigh); 
    140141} 
    141142 
    … …  
    144145   uint8_t stat; 
    145146 
    146    _setcs(kCSLow); 
    147    spi_send(kCmdReadStatus); 
    148    stat = spi_recv(); 
    149    _setcs(kCSHigh); 
     147   spi_ctxt->set_cs(kCSLow); 
     148   spi_ctxt->send(kCmdReadStatus); 
     149   stat = spi_ctxt->recv(); 
     150   spi_ctxt->set_cs(kCSHigh); 
    150151 
    151152   return stat; 
    … …  
    154155void mcp_bit_mod(uint8_t addr, uint8_t mask, uint8_t data) 
    155156{ 
    156    _setcs(kCSLow); 
    157    spi_send(kCmdBitModify); 
    158    spi_send(addr); 
    159    spi_send(mask); 
    160    spi_send(data); 
    161    _setcs(kCSHigh); 
     157   spi_ctxt->set_cs(kCSLow); 
     158   spi_ctxt->send(kCmdBitModify); 
     159   spi_ctxt->send(addr); 
     160   spi_ctxt->send(mask); 
     161   spi_ctxt->send(data); 
     162   spi_ctxt->set_cs(kCSHigh); 
    162163} 
    163164 
    … …  
    166167   uint8_t i; 
    167168   uint8_t tmp; 
    168    _setcs(kCSLow); 
     169   spi_ctxt->set_cs(kCSLow); 
    169170   CANMSG_ZERO(msg); 
    170    spi_send(kCmdReadRXBuffer | rxbuf); 
    171    tmp = spi_recv(); //RXBnSIDH 
     171   spi_ctxt->send(kCmdReadRXBuffer | rxbuf); 
     172   tmp = spi_ctxt->recv(); //RXBnSIDH 
    172173   msg->addr[0] = tmp >> 3; 
    173174   msg->addr[1] = ((tmp & 0x07) << 5); 
    174    tmp = spi_recv(); // RXBnSIDL 
     175   tmp = spi_ctxt->recv(); // RXBnSIDL 
    175176   if (tmp & mRXBSIDL_IDE) 
    176177      CANMSG_SET_FLAG(msg, mCANMSG_EX); 
    … …  
    178179      CANMSG_SET_FLAG(msg, mCANMSG_RTR); 
    179180   msg->addr[1] |= ((tmp & 0xE0) >> 3) | (tmp & 0x03); 
    180    msg->addr[2] = spi_recv(); // RXBnEID8 
    181    msg->addr[3] = spi_recv(); // RXBnEID0 
    182  
    183    tmp = spi_recv(); //DLC 
     181   msg->addr[2] = spi_ctxt->recv(); // RXBnEID8 
     182   msg->addr[3] = spi_ctxt->recv(); // RXBnEID0 
     183 
     184   tmp = spi_ctxt->recv(); //DLC 
    184185   msg->dlc = tmp & 0x0F; 
    185186   if (CANMSG_TST_FLAG(msg, mCANMSG_EX) && (tmp & mRXBDLC_RTR)) 
    … …  
    189190   if (!CANMSG_TST_FLAG(msg, mCANMSG_RTR)) { 
    190191      for (i = 0; i < msg->dlc; i++) 
    191          msg->data[i] = spi_recv(); 
    192    } 
    193  
    194    _setcs(kCSHigh); 
     192         msg->data[i] = spi_ctxt->recv(); 
     193   } 
     194 
     195   spi_ctxt->set_cs(kCSHigh); 
    195196} 
    196197 
    … …  
    224225   uint8_t i; 
    225226 
    226    _setcs(kCSLow); 
    227    spi_send(kCmdLoadTXBuffer | txbuf); 
    228  
    229    spi_send((msg->addr[0] << 3) | (msg->addr[1] >> 5)); 
    230    spi_send( ((msg->addr[1] & 0x1C) << 3) | (msg->addr[1] & 0x03) 
     227   spi_ctxt->set_cs(kCSLow); 
     228   spi_ctxt->send(kCmdLoadTXBuffer | txbuf); 
     229 
     230   spi_ctxt->send((msg->addr[0] << 3) | (msg->addr[1] >> 5)); 
     231   spi_ctxt->send( ((msg->addr[1] & 0x1C) << 3) | (msg->addr[1] & 0x03) 
    231232         | ((msg->flags & mCANMSG_EX) ? 0x08 : 0x00)); 
    232    spi_send(msg->addr[2]); 
    233    spi_send(msg->addr[3]); 
    234  
    235    spi_send(msg->dlc | (CANMSG_TST_FLAG(msg, mCANMSG_RTR) ? mTXBDLC_RTR : 0)); 
     233   spi_ctxt->send(msg->addr[2]); 
     234   spi_ctxt->send(msg->addr[3]); 
     235 
     236   spi_ctxt->send(msg->dlc | (CANMSG_TST_FLAG(msg, mCANMSG_RTR) ? mTXBDLC_RTR : 0)); 
    236237 
    237238   if (!CANMSG_TST_FLAG(msg, mCANMSG_RTR)) { 
    238239      for (i = 0; i < msg->dlc; i++) 
    239          spi_send(msg->data[i]); 
    240    } 
    241  
    242    _setcs(kCSHigh); 
     240         spi_ctxt->send(msg->data[i]); 
     241   } 
     242 
     243   spi_ctxt->set_cs(kCSHigh); 
    243244 
    244245} 
    … …  
    274275   } 
    275276 
    276    _setcs(kCSLow); 
    277    spi_send(kCmdRTS | rts); 
    278    _setcs(kCSHigh); 
     277   spi_ctxt->set_cs(kCSLow); 
     278   spi_ctxt->send(kCmdRTS | rts); 
     279   spi_ctxt->set_cs(kCSHigh); 
    279280} 
    280281 

  • trunk/electronics/avr/can-bridge/mcp.h

    r571 r584  
    1  
    21 
    32 
    … …  
    143142} 
    144143 
     144typedef struct { 
     145   uint8_t (*send)(uint8_t); 
     146   uint8_t (*recv)(void); 
     147   void (*set_cs)(uint8_t); 
     148} spi_context_t; 
    145149 
    146  
    147  
    148 void mcp_init(can_handler_t handlers[]); 
     150void mcp_init(const can_handler_t handlers[], spi_context_t *); 
    149151void mcp_reset(void); 
    150152void mcp_read(uint8_t addr, uint8_t len, uint8_t *buf); 
    … …  
    158160void mcp_bit_mod(uint8_t addr, uint8_t mask, uint8_t data); 
    159161 
     162 
     163 
     164 

  • trunk/electronics/avr/can-bridge/spi.c

    r564 r584  
    1212} 
    1313 
    14 int8_t spi_send(int8_t d) 
     14uint8_t spi_send(uint8_t d) 
    1515{ 
    1616        SPDR = d; 
    17          
    1817        while (!(SPSR & (1 << SPIF))); 
    19          
    2018        return SPDR; 
    2119} 
    2220 
     21uint8_t spi_recv(void) 
     22{ 
     23   return spi_send(0x0); 
     24} 
     25 
     26 
     27 
     28 

  • trunk/electronics/avr/can-bridge/spi.h

    r564 r584  
    1 #define spi_recv() spi_send(0x0) 
    2  
    31#define SPIDDR DDRB 
    42#define SPIPORT PORTB 
    … …  
    108 
    119void spi_init(); 
    12 int8_t spi_send(int8_t d); 
     10uint8_t spi_send(uint8_t d); 
     11uint8_t spi_recv(void); 
    1312 
    1413 
    15 #define spi_cslow(x) SPIPORT &= ~(1 << x); 
    16 #define spi_cshigh(x) SPIPORT |= (1 << x); 
     14//#define spi_cslow(x) SPIPORT &= ~(1 << x); 
     15//#define spi_cshigh(x) SPIPORT |= (1 << x);