Atmel SAM25W I2C und WIFI

[Peter (Gast)]

Hallo!

Ich möchte auf meinem Atmel SAMW25 den I2C Bus nutzen, jedoch bekomme 
ich das ganze nicht so ganz gebacken.

Ich nutze erst einmal das Acces Point Beispiel von Atmel da der SAMW25 
später einen Acces Point aufbauen soll, dies funktioniert schon ganz 
gut. Nun möchte ich die I2C Funktion nutzen.

Ich habe dieses tutorial gefunden. Ich habe mal mit einem Oszilloskop 
nachgemessen (an Pin PA08 -> SDA), die Leitung bleibt aber dauerhaft auf 
HIGH, kein Signal zu erkennen.

Nehme ich jedoch den kompletten WIFI Krempel heraus, funktioniert es 
einwandfrei. Kann es sein das die WIFI Funktion SERCOM2 nutzt? Wie kann 
ich meinen I2C Port (PA08 und PA09) auf ein anderen SERCOM legen um 
diesen Fehler eventuell zu beheben?.

Hier ist mein Code, tut mir leid das er so lang und unübersichtlich ist, 
das meiste stammt aus dem Wifi Tutorial.

Wie gesagt, wenn ich alles aus der Hauptschleife herausnehme und dort 
nur noch die wake_mpu9250() Funktion drin steht, läuft der I2C Bus.

Auch habe ich versucht in der Wake_mpu9250 funktion den SERCOM Bus auf 0 
zu stellen, jedoch funktioniert der I2C Bus dann auch nicht.

Ich bin noch neu in der ARM (ATMEL) Welt, von daher habt bitte etwas 
Nachsicht mit mir :)


Danke

Peter

#include "asf.h"
#include "main.h"
#include "driver/include/m2m_wifi.h"
#include "driver/source/nmasic.h"

#define STRING_EOL    "\r\n"
#define STRING_HEADER "-- WINC1500 AP mode example --"STRING_EOL \
"-- "BOARD_NAME " --"STRING_EOL  \
"-- Compiled: "__DATE__ " "__TIME__ " --"STRING_EOL


struct i2c_master_module i2c_master_instance;

/** UART module for debug. */
static struct usart_module cdc_uart_module;


/**
* \brief Configure UART console.
*/
static void configure_console(void)
{
  struct usart_config usart_conf;

  usart_get_config_defaults(&usart_conf);
  usart_conf.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
  usart_conf.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
  usart_conf.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
  usart_conf.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
  usart_conf.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
  usart_conf.baudrate    = 115200;

  stdio_serial_init(&cdc_uart_module, EDBG_CDC_MODULE, &usart_conf);
  usart_enable(&cdc_uart_module);
}

/**
* \brief Callback to get the Wi-Fi status update.
*
* \param[in] u8MsgType type of Wi-Fi notification. Possible types are:
*  - [M2M_WIFI_RESP_CON_STATE_CHANGED](@ref M2M_WIFI_RESP_CON_STATE_CHANGED)
*  - [M2M_WIFI_REQ_DHCP_CONF](@ref M2M_WIFI_REQ_DHCP_CONF)
* \param[in] pvMsg A pointer to a buffer containing the notification parameters
* (if any). It should be casted to the correct data type corresponding to the
* notification type.
*/
static void wifi_cb(uint8_t u8MsgType, void *pvMsg)
{
  switch (u8MsgType) {
    case M2M_WIFI_RESP_CON_STATE_CHANGED:
    {
      tstrM2mWifiStateChanged *pstrWifiState = (tstrM2mWifiStateChanged *)pvMsg;
      if (pstrWifiState->u8CurrState == M2M_WIFI_CONNECTED) {
        } else if (pstrWifiState->u8CurrState == M2M_WIFI_DISCONNECTED) {
        printf("Station disconnected\r\n");
      }

      break;
    }

    case M2M_WIFI_REQ_DHCP_CONF:
    {
      uint8_t *pu8IPAddress = (uint8_t *)pvMsg;
      printf("Station connected\r\n");
      printf("Station IP is %u.%u.%u.%u\r\n",
      pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[2], pu8IPAddress[3]);
      break;
    }

    default:
    {
      break;
    }
  }
}

/**
* \brief Main application function.
*/
int main(void)
{
  tstrWifiInitParam param;
  tstrM2MAPConfig strM2MAPConfig;
  int8_t ret;

  /* Initialize the board. */
  system_init();

  /* Initialize the UART console. */
  configure_console();
  printf(STRING_HEADER);

  /* Initialize the BSP. */
  nm_bsp_init();

  /* Initialize Wi-Fi parameters structure. */
  memset((uint8_t *)&param, 0, sizeof(tstrWifiInitParam));

  /* Initialize Wi-Fi driver with data and status callbacks. */
  param.pfAppWifiCb = wifi_cb;
  ret = m2m_wifi_init(&param);
  if (M2M_SUCCESS != ret) {
    printf("main: m2m_wifi_init call error!(%d)\r\n", ret);
    while (1) {
    }
  }

  /* Initialize AP mode parameters structure with SSID, channel and OPEN security type. */
  memset(&strM2MAPConfig, 0x00, sizeof(tstrM2MAPConfig));
  strcpy((char *)&strM2MAPConfig.au8SSID, MAIN_WLAN_SSID);
  strM2MAPConfig.u8ListenChannel = MAIN_WLAN_CHANNEL;
  strM2MAPConfig.u8SecType = MAIN_WLAN_AUTH;

  strM2MAPConfig.au8DHCPServerIP[0] = 192;
  strM2MAPConfig.au8DHCPServerIP[1] = 168;
  strM2MAPConfig.au8DHCPServerIP[2] = 1;
  strM2MAPConfig.au8DHCPServerIP[3] = 1;

  #if USE_WEP
  strcpy((char *)&strM2MAPConfig.au8WepKey, MAIN_WLAN_WEP_KEY);
  strM2MAPConfig.u8KeySz = strlen(MAIN_WLAN_WEP_KEY);
  strM2MAPConfig.u8KeyIndx = MAIN_WLAN_WEP_KEY_INDEX;
  #endif

  /* Bring up AP mode with parameters structure. */
  ret = m2m_wifi_enable_ap(&strM2MAPConfig);
  if (M2M_SUCCESS != ret) {
    printf("main: m2m_wifi_enable_ap call error!\r\n");
    while (1) {
    }
  }

  printf("AP mode started. You can connect to %s.\r\n", (char *)MAIN_WLAN_SSID);

  while (1) {
    /* Handle pending events from network controller. */
    while (m2m_wifi_handle_events(NULL) != M2M_SUCCESS) {
    }
    bool pin_state = port_pin_get_input_level(BUTTON_0_PIN);
    port_pin_set_output_level(PIN_PA23, pin_state);
    
    
    wake_mpu9250();
  }

  return 0;
}

void wake_mpu9250(void){

  #define ADDRESS     0x68   // I2C address of the sensor

  /* Initialize config structure and software module. */
  struct i2c_master_config config_i2c_master;
  i2c_master_get_config_defaults(&config_i2c_master);
  /* Change buffer timeout to something longer. */
  config_i2c_master.buffer_timeout = 10000;

  /* Initialize and enable device with config. */
  i2c_master_init(&i2c_master_instance, SERCOM2, &config_i2c_master);
  i2c_master_enable(&i2c_master_instance);

  uint8_t maxRetries = 64;

  enum status_code powerOnStatus;
  // POWER ON THE SENSOR!
  {
    uint8_t retryCount = 0;

    static uint8_t buffer[2] = { 0x6b, 0x0 }; // power on packet
    struct i2c_master_packet packet = {
      .address = ADDRESS,
      .data = buffer,
      .data_length = 2,
    };

    while ((powerOnStatus = i2c_master_write_packet_wait(&i2c_master_instance, &packet)) != STATUS_OK)
    {
      
      if (++retryCount >= maxRetries) break;
    }
  }

  uint8_t whoAmI;
  {
    uint8_t retryCount = 0;

    static uint8_t buffer[1] = { 0x75 }; // who am I
    struct i2c_master_packet packet = {
      .address = ADDRESS,
      .data = buffer,
      .data_length = 1,
    };

    // here use the no_stop variant
    while (i2c_master_write_packet_wait_no_stop(&i2c_master_instance, &packet) != STATUS_OK)
    {
      if (++retryCount >= maxRetries) break;
    }

    // and here it sends stop automatically
    UNUSED(i2c_master_read_packet_wait(&i2c_master_instance, &packet));
    whoAmI = buffer[0];
    
    printf("BUFFER: %s\r\n", whoAmI);
  }
  
}
// check that whoAmI == 0x68

[Peter (Gast)]

Achja, das I2C Beispiel kommt von hier:
http://blog.telenor.io/2015/12/01/asf-i2c.html

[Peter (Gast)]

Ich schieb den Thread mal wieder hoch :)