import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
+import android.os.Looper;
import android.util.Log;
import android.widget.Toast;
import android.location.Location;
import android.location.LocationManager;
import android.location.LocationListener;
+import android.location.Criteria;
import org.altusmetrum.altoslib_1.*;
// Listen for GPS and Network position updates
LocationManager locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
- locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
- locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, this);
+ locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 1000, 1, this);
+// locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, this);
}
@Override
return meters * (100 / (2.54 * 12));
}
+ public static double feet_to_meters(double feet) {
+ return feet * 12 * 2.54 / 100.0;
+ }
+
public static double meters_to_miles(double meters) {
return meters_to_feet(meters) / 5280;
}
return v;
}
+ public double parse(String s) throws NumberFormatException {
+ double v = Double.parseDouble(s);
+ if (AltosConvert.imperial_units)
+ v = AltosConvert.feet_to_meters(v);
+ return v;
+ }
+
public String show_units() {
if (AltosConvert.imperial_units)
return "ft";
public final static int product_telemega = 0x0023;
public final static int product_megadongle = 0x0024;
public final static int product_telegps = 0x0025;
+ public final static int product_easymini = 0x0026;
+ public final static int product_telemini = 0x0027;
public final static int product_altusmetrum_min = 0x000a;
- public final static int product_altusmetrum_max = 0x0025;
+ public final static int product_altusmetrum_max = 0x002c;
public final static int product_any = 0x10000;
public final static int product_basestation = 0x10000 + 1;
public double ground_altitude;
public double altitude;
public double height;
+ public double pressure;
public double acceleration;
public double battery;
public double temperature;
drogue_sense = data.drogue_voltage();
main_sense = data.main_voltage();
battery = data.battery_voltage();
+ pressure = data.pressure();
tick = data.tick;
state = data.state;
public class AltosConfigUI
extends AltosUIDialog
- implements ActionListener, ItemListener, DocumentListener, AltosConfigValues
+ implements ActionListener, ItemListener, DocumentListener, AltosConfigValues, AltosUnitsListener
{
Container pane;
ActionListener listener;
- static String[] main_deploy_values = {
+ static String[] main_deploy_values_m = {
"100", "150", "200", "250", "300", "350",
"400", "450", "500"
};
+ static String[] main_deploy_values_ft = {
+ "250", "500", "750", "1000", "1250", "1500",
+ "1750", "2000"
+ };
+
static String[] apogee_delay_values = {
"0", "1", "2", "3", "4", "5"
};
c.anchor = GridBagConstraints.LINE_START;
c.insets = il;
c.ipady = 5;
- main_deploy_label = new JLabel("Main Deploy Altitude(m):");
+ main_deploy_label = new JLabel(get_main_deploy_label());
pane.add(main_deploy_label, c);
c = new GridBagConstraints();
c.anchor = GridBagConstraints.LINE_START;
c.insets = ir;
c.ipady = 5;
- main_deploy_value = new JComboBox(main_deploy_values);
+ main_deploy_value = new JComboBox(main_deploy_values());
main_deploy_value.setEditable(true);
main_deploy_value.addItemListener(this);
pane.add(main_deploy_value, c);
close.setActionCommand("Close");
addWindowListener(new ConfigListener(this));
+ AltosPreferences.register_units_listener(this);
}
/* Once the initial values are set, the config code will show the dialog */
AltosConfigPyroUI pyro_ui;
+ public void dispose() {
+ AltosPreferences.unregister_units_listener(this);
+ }
+
/* Listen for events from our buttons */
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
}
public void set_main_deploy(int new_main_deploy) {
- main_deploy_value.setSelectedItem(Integer.toString(new_main_deploy));
+ main_deploy_value.setSelectedItem(AltosConvert.height.say(new_main_deploy));
main_deploy_value.setEnabled(new_main_deploy >= 0);
}
public int main_deploy() {
- return Integer.parseInt(main_deploy_value.getSelectedItem().toString());
+ return (int) (AltosConvert.height.parse(main_deploy_value.getSelectedItem().toString()) + 0.5);
+ }
+
+ String get_main_deploy_label() {
+ return String.format("Main Deploy Altitude(%s):", AltosConvert.height.show_units());
+ }
+
+ String[] main_deploy_values() {
+ if (AltosConvert.imperial_units)
+ return main_deploy_values_ft;
+ else
+ return main_deploy_values_m;
+ }
+
+ void set_main_deploy_values() {
+ String[] v = main_deploy_values();
+ while (main_deploy_value.getItemCount() > 0)
+ main_deploy_value.removeItemAt(0);
+ for (int i = 0; i < v.length; i++)
+ main_deploy_value.addItem(v[i]);
+ main_deploy_value.setMaximumRowCount(v.length);
+ }
+
+ public void units_changed(boolean imperial_units) {
+ main_deploy_label.setText(get_main_deploy_label());
+ set_main_deploy_values();
+ listener.actionPerformed(new ActionEvent(this, 0, "Reset"));
}
public void set_apogee_delay(int new_apogee_delay) {
}
}
-class AltosDbm extends AltosUnits {
+class AltosPressure extends AltosUnits {
- public double value(double v) {
- return v;
+ public double value(double p) {
+ return p;
}
public String show_units() {
- return "dBm";
+ return "Pa";
}
public String say_units() {
- return "d b m";
+ return "pascals";
}
public int show_fraction(int width) {
static final private Color height_color = new Color(194,31,31);
static final private Color gps_height_color = new Color(150,31,31);
+ static final private Color pressure_color = new Color (225,31,31);
static final private Color range_color = new Color(100, 31, 31);
static final private Color distance_color = new Color(100, 31, 194);
static final private Color speed_color = new Color(31,194,31);
static final private Color state_color = new Color(0,0,0);
static AltosVoltage voltage_units = new AltosVoltage();
+ static AltosPressure pressure_units = new AltosPressure();
static AltosNsat nsat_units = new AltosNsat();
static AltosDbm dbm_units = new AltosDbm();
AltosUIAxis height_axis, speed_axis, accel_axis, voltage_axis, temperature_axis, nsat_axis, dbm_axis;
- AltosUIAxis distance_axis;
+ AltosUIAxis distance_axis, pressure_axis;
public AltosGraph(AltosUIEnable enable, AltosFlightStats stats, AltosGraphDataSet dataSet) {
super(enable);
height_axis = newAxis("Height", AltosConvert.height, height_color);
+ pressure_axis = newAxis("Pressure", pressure_units, pressure_color, 0);
speed_axis = newAxis("Speed", AltosConvert.speed, speed_color);
accel_axis = newAxis("Acceleration", AltosConvert.accel, accel_color);
voltage_axis = newAxis("Voltage", voltage_units, voltage_color);
height_color,
true,
height_axis);
+ addSeries("Pressure",
+ AltosGraphDataPoint.data_pressure,
+ pressure_units,
+ pressure_color,
+ false,
+ pressure_axis);
addSeries("Speed",
AltosGraphDataPoint.data_speed,
AltosConvert.speed,
public static final int data_temperature = 12;
public static final int data_range = 13;
public static final int data_distance = 14;
+ public static final int data_pressure = 15;
public double x() throws AltosUIDataMissing {
if (state.data.time < -2)
if (state.from_pad != null)
y = state.from_pad.distance;
break;
+ case data_pressure:
+ y = state.pressure;
+ break;
}
if (y == AltosRecord.MISSING)
throw new AltosUIDataMissing(index);
if (want_product == AltosUILib.product_altimeter)
return matchProduct(AltosUILib.product_telemetrum) ||
matchProduct(AltosUILib.product_telemega) ||
- matchProduct(AltosUILib.product_telegps);
+ matchProduct(AltosUILib.product_telegps) ||
+ matchProduct(AltosUILib.product_easymini) ||
+ matchProduct(AltosUILib.product_telemini);
int have_product = getProduct();
fileMenu.add(exitAction);
exitAction.addActionListener(this);
+ JButton downloadButton = new JButton ("Download");
+ downloadButton.addActionListener(this);
+ menuBar.add(downloadButton);
+
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
addWindowListener(new WindowAdapter() {
@Override
}
#if NEED_RADIO_RSSI
else
- ao_radio_rssi = AO_RSSI_FROM_RADIO(((uint8_t *)packet)[size - 1]);
+ ao_radio_rssi = AO_RSSI_FROM_RADIO(((uint8_t *)packet)[size - 2]);
#endif
ao_radio_put();
return ao_radio_dma_done;
{
/* Set pad mode - we can fly! */
ao_flight_state = ao_flight_pad;
-#if HAS_USB && HAS_RADIO && !HAS_FLIGHT_DEBUG && !HAS_SAMPLE_PROFILE
+#if HAS_USB && !HAS_FLIGHT_DEBUG && !HAS_SAMPLE_PROFILE
/* Disable the USB controller in flight mode
* to save power
*/
ao_cmd_register(&ao_log_cmds[0]);
+#ifndef HAS_ADC
+#error Define HAS_ADC for ao_log.c
+#endif
+#if HAS_ADC
/* Create a task to log events to eeprom */
ao_add_task(&ao_log_task, ao_log, "log");
+#endif
}
return 1;
}
+#if HAS_ADC
static __data uint8_t ao_log_data_pos;
/* a hack to make sure that ao_log_megas fill the eeprom block in even units */
ao_sleep(&ao_log_running);
}
}
+#endif
uint16_t
ao_log_flight(uint8_t slot)
static uint8_t ao_m25_numchips; /* number of chips detected */
#endif
static uint8_t ao_m25_total; /* total sectors available */
-static uint8_t ao_m25_wip; /* write in progress */
+static ao_port_t ao_m25_wip; /* write in progress */
static __xdata uint8_t ao_m25_mutex;
cs = ao_m25_set_address(pos);
- ao_m25_wait_wip(cs);
ao_m25_write_enable(cs);
ao_m25_instruction[0] = M25_SE;
static __pdata uint16_t ao_pad_arm_time;
static __pdata uint8_t ao_pad_box;
static __xdata uint8_t ao_pad_disabled;
+static __pdata uint16_t ao_pad_packet_time;
#define DEBUG 1
query.arm_status = AO_PAD_ARM_STATUS_UNKNOWN;
arm_beep_time = 0;
}
+ if ((ao_time() - ao_pad_packet_time) > AO_SEC_TO_TICKS(2))
+ cur |= AO_LED_RED;
+ else if (ao_radio_cmac_rssi < -90)
+ cur |= AO_LED_AMBER;
+ else
+ cur |= AO_LED_GREEN;
for (c = 0; c < AO_PAD_NUM; c++) {
int16_t sense = packet->adc.sense[c];
query.igniter_status[c] = status;
}
if (cur != prev) {
- PRINTD("change leds from %02x to %02x mask %02x\n",
- prev, cur, AO_LED_CONTINUITY_MASK|AO_LED_ARMED);
- ao_led_set_mask(cur, AO_LED_CONTINUITY_MASK | AO_LED_ARMED);
+ PRINTD("change leds from %02x to %02x\n",
+ prev, cur);
+ FLUSHD();
+ ao_led_set(cur);
prev = cur;
}
ao_pad_box = 0;
ao_led_set(0);
- ao_led_on(AO_LED_POWER);
for (;;) {
FLUSHD();
while (ao_pad_disabled)
ao_sleep(&ao_pad_disabled);
ret = ao_radio_cmac_recv(&command, sizeof (command), 0);
- PRINTD ("cmac_recv %d\n", ret);
+ PRINTD ("cmac_recv %d %d\n", ret, ao_radio_cmac_rssi);
if (ret != AO_RADIO_CMAC_OK)
continue;
+ ao_pad_packet_time = ao_time();
ao_pad_box = ao_pad_read_box();
/* Don't try the SPI bus during initialization */
if (!ao_cur_task)
return;
- ao_spi_get_bit(AO_PCA9922_CS_PORT, AO_PCA9922_CS_PIN, AO_PCA9922_CS, AO_PCA9922_SPI_BUS, AO_SPI_SPEED_FAST);
+ ao_mutex_get(&ao_spi_mutex);
+ ao_spi_set_speed(AO_SPI_SPEED_FAST);
+ AO_PCA9922_CS = 1;
ao_spi_send(&ao_led_state, 1, AO_PCA9922_SPI_BUS);
- ao_spi_put_bit(AO_PCA9922_CS_PORT, AO_PCA9922_CS_PIN, AO_PCA9922_CS, AO_PCA9922_SPI_BUS);
+ AO_PCA9922_CS = 0;
+ ao_mutex_put(&ao_spi_mutex);
}
void
#
ALTOS_SRC = \
ao_interrupt.c \
+ ao_boot_chain.c \
ao_romconfig.c \
ao_product.c \
ao_mutex.c \
ao_config.c \
ao_timer_lpc.c \
ao_exti_lpc.c \
- ao_serial_lpc.c \
ao_usb_lpc.c \
ao_spi_lpc.c \
ao_adc_lpc.c \
PRODUCT=EasyMini-v0.1
PRODUCT_DEF=-DEASYMINI_V_0_1
-IDPRODUCT=0x000a
+IDPRODUCT=0x0026
CFLAGS = $(PRODUCT_DEF) $(LPC_CFLAGS) -g -Os
LDFLAGS=-L../lpc -Wl,-Taltos.ld
-$(PROG): Makefile $(OBJ)
+$(PROG): Makefile $(OBJ) altos.ld
$(call quiet,CC) $(LDFLAGS) $(CFLAGS) -o $(PROG) $(OBJ) $(SAT_CLIB) -lgcc
ao_product.h: ao-make-product.5c ../Version
#define HAS_BEEP 1
#define HAS_LED 1
+#define IS_FLASH_LOADER 0
+
/* Crystal on the board */
#define AO_LPC_CLKIN 12000000
#define HAS_USB_CONNECT 0
#define HAS_USB_VBUS 0
+#define HAS_USB_PULLUP 1
+#define AO_USB_PULLUP_PORT 0
+#define AO_USB_PULLUP_PIN 20
#define PACKET_HAS_SLAVE 0
/* USART */
-#define HAS_SERIAL 1
+#define HAS_SERIAL 0
#define USE_SERIAL_0_STDIN 1
#define SERIAL_0_18_19 1
#define SERIAL_0_14_15 0
--- /dev/null
+#
+# AltOS flash loader build
+#
+#
+
+TOPDIR=../..
+HARDWARE=easymini-v0.1
+include $(TOPDIR)/lpc/Makefile-flash.defs
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_PINS_H_
+#define _AO_PINS_H_
+
+#include <ao_flash_lpc_pins.h>
+
+#define AO_BOOT_PIN 1
+#define AO_BOOT_APPLICATION_GPIO 0
+#define AO_BOOT_APPLICATION_PIN 19
+#define AO_BOOT_APPLICATION_VALUE 1
+#define AO_BOOT_APPLICATION_MODE AO_EXTI_MODE_PULL_UP
+
+#define HAS_USB_PULLUP 1
+#define AO_USB_PULLUP_PORT 0
+#define AO_USB_PULLUP_PIN 20
+
+#endif /* _AO_PINS_H_ */
--- /dev/null
+/*
+ * Copyright © 2012 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+MEMORY {
+ rom : ORIGIN = 0x00000000, LENGTH = 4K
+ ram : ORIGIN = 0x10000000, LENGTH = 4k - 128 - 32
+ usb (!x) : ORIGIN = 0x20004000 + 2K - 256, LENGTH = 256
+ stack (!w) : ORIGIN = 0x10000000 + 4K - 128 - 32, LENGTH = 128
+}
+
+INCLUDE registers.ld
+
+EXTERN (lpc_interrupt_vector)
+
+SECTIONS {
+ /*
+ * Rom contents
+ */
+
+ .interrupt : {
+ __text_start__ = .;
+ *(.interrupt) /* Interrupt vectors */
+
+ } > rom
+
+ .text ORIGIN(rom) + 0x100 : {
+ ao_romconfig.o(.romconfig*)
+ ao_product.o(.romconfig*)
+
+ *(.text*) /* Executable code */
+ *(.ARM.exidx* .gnu.linkonce.armexidx.*)
+ *(.rodata*) /* Constants */
+ __text_end__ = .;
+ } > rom
+
+ /* Boot data which must live at the start of ram so that
+ * the application and bootloader share the same addresses.
+ * This must be all uninitialized data
+ */
+ .boot ORIGIN(ram) + SIZEOF(.interrupt) (NOLOAD) : {
+ __boot_start__ = .;
+ *(.boot)
+ __boot_end__ = .;
+ } >ram
+
+ /* Data -- relocated to RAM, but written to ROM
+ */
+ .data : {
+ __data_start__ = .;
+ *(.data) /* initialized data */
+ __data_end__ = .;
+ } >ram AT>rom
+
+
+ .bss : {
+ __bss_start__ = .;
+ *(.bss)
+ *(COMMON)
+ __bss_end__ = .;
+ } >ram
+
+ PROVIDE(__stack__ = ORIGIN(ram) + LENGTH(ram));
+ PROVIDE(end = .);
+}
+
+ENTRY(start);
--- /dev/null
+/*
+ * Copyright © 2012 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+MEMORY {
+ rom (rx) : ORIGIN = 0x00000000, LENGTH = 32K
+ ram (!w) : ORIGIN = 0x10000000, LENGTH = 4K - 128 - 32
+ usb (!x) : ORIGIN = 0x20004000 + 2K - 256, LENGTH = 256
+ stack (!w) : ORIGIN = 0x10000000 + 4K - 128 - 32, LENGTH = 128
+}
+
+INCLUDE registers.ld
+
+EXTERN (lpc_interrupt_vector)
+
+SECTIONS {
+ /*
+ * Rom contents
+ */
+
+ .text ORIGIN(rom) : {
+ __text_start__ = .;
+ *(.interrupt) /* Interrupt vectors */
+
+ . = ORIGIN(rom) + 0x100;
+
+ ao_romconfig.o(.romconfig*)
+ ao_product.o(.romconfig*)
+
+ *(.text*) /* Executable code */
+ *(.rodata*) /* Constants */
+
+ } > rom
+
+ .ARM.exidx : {
+ *(.ARM.exidx* .gnu.linkonce.armexidx.*)
+ __text_end__ = .;
+ } > rom
+
+ /* Boot data which must live at the start of ram so that
+ * the application and bootloader share the same addresses.
+ * This must be all uninitialized data
+ */
+ .boot (NOLOAD) : {
+ __boot_start__ = .;
+ *(.boot)
+ . = ALIGN(4);
+ __boot_end__ = .;
+ } >ram
+
+ /* Data -- relocated to RAM, but written to ROM
+ */
+ .data ORIGIN(ram) : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
+ __data_start__ = .;
+ *(.data) /* initialized data */
+ __data_end__ = .;
+ __bss_start__ = .;
+ } >ram
+
+ .bss : {
+ *(.bss)
+ *(COMMON)
+ __bss_end__ = .;
+ } >ram
+ PROVIDE(end = .);
+
+ PROVIDE(__stack__ = ORIGIN(stack) + LENGTH(stack));
+}
+
+ENTRY(start);
+
+
*/
MEMORY {
- rom (rx) : ORIGIN = 0x00000000, LENGTH = 32K
+ rom (rx) : ORIGIN = 0x00001000, LENGTH = 28K
ram (!w) : ORIGIN = 0x10000000, LENGTH = 4K - 128
usb (!x) : ORIGIN = 0x20004000 + 2K - 256, LENGTH = 256
stack (!w) : ORIGIN = 0x10000000 + 4K - 128, LENGTH = 128
* Rom contents
*/
- .text ORIGIN(rom) : {
- __text_start__ = .;
+ .interrupt ORIGIN(ram) : AT (ORIGIN(rom)) {
+ __interrupt_start__ = .;
+ __interrupt_rom__ = ORIGIN(rom);
*(.interrupt) /* Interrupt vectors */
+ __interrupt_end__ = .;
+ } > ram
- . = ORIGIN(rom) + 0x100;
+ .text ORIGIN(rom) + 0x100 : {
+ __text_start__ = .;
ao_romconfig.o(.romconfig*)
ao_product.o(.romconfig*)
__text_end__ = .;
} > rom
+ /* Boot data which must live at the start of ram so that
+ * the application and bootloader share the same addresses.
+ * This must be all uninitialized data
+ */
+ .boot : {
+ __boot_start__ = .;
+ *(.boot)
+ . = ALIGN(4);
+ __boot_end__ = .;
+ } >ram
+
/* Data -- relocated to RAM, but written to ROM
*/
- .data ORIGIN(ram) : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
+ .data : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
__data_start__ = .;
*(.data) /* initialized data */
__data_end__ = .;
} >ram
.bss : {
+ __bss_start__ = .;
*(.bss)
*(COMMON)
__bss_end__ = .;
# endif
#endif
-static uint8_t ao_adc_ready;
+#define AO_ADC_MASK ((AO_ADC_0 << 0) | \
+ (AO_ADC_1 << 1) | \
+ (AO_ADC_2 << 2) | \
+ (AO_ADC_3 << 3) | \
+ (AO_ADC_4 << 4) | \
+ (AO_ADC_5 << 5) | \
+ (AO_ADC_6 << 6) | \
+ (AO_ADC_7 << 7))
+
+#define AO_ADC_CLKDIV (AO_LPC_SYSCLK / 4500000)
+
+static uint8_t ao_adc_ready;
+
+#define sample(id) (*out++ = lpc_adc.dr[id] >> 1)
void lpc_adc_isr(void)
{
uint32_t stat = lpc_adc.stat;
- uint16_t *out = (uint16_t *) &ao_data_ring[ao_data_head].adc;
- vuint32_t *in = &lpc_adc.dr[0];
+ uint16_t *out;
+ /* Turn off burst mode */
lpc_adc.cr = 0;
lpc_adc.stat = 0;
/* Store converted values in packet */
+ out = (uint16_t *) &ao_data_ring[ao_data_head].adc;
#if AO_ADC_0
- *out++ = lpc_adc.dr[0] >> 1;
+ sample(0);
#endif
#if AO_ADC_1
- *out++ = lpc_adc.dr[1] >> 1;
+ sample(1);
#endif
#if AO_ADC_2
- *out++ = lpc_adc.dr[2] >> 1;
+ sample(2);
#endif
#if AO_ADC_3
- *out++ = lpc_adc.dr[3] >> 1;
+ sample(3);
#endif
#if AO_ADC_4
- *out++ = lpc_adc.dr[4] >> 1;
+ sample(4);
#endif
#if AO_ADC_5
- *out++ = lpc_adc.dr[5] >> 1;
+ sample(5);
#endif
#if AO_ADC_6
- *out++ = lpc_adc.dr[6] >> 1;
+ sample(6);
#endif
#if AO_ADC_7
- *out++ = lpc_adc.dr[7] >> 1;
+ sample(7);
#endif
AO_DATA_PRESENT(AO_DATA_ADC);
ao_adc_ready = 1;
}
-#define AO_ADC_MASK ((AO_ADC_0 << 0) | \
- (AO_ADC_1 << 1) | \
- (AO_ADC_2 << 2) | \
- (AO_ADC_3 << 3) | \
- (AO_ADC_4 << 4) | \
- (AO_ADC_5 << 5) | \
- (AO_ADC_6 << 6) | \
- (AO_ADC_7 << 7))
-
-#define AO_ADC_CLKDIV (AO_LPC_CLKOUT / 4500000)
/*
* Start the ADC sequence using the DMA engine
lpc_nvic_set_enable(LPC_ISR_ADC_POS);
lpc_nvic_set_priority(LPC_ISR_ADC_POS, AO_LPC_NVIC_CLOCK_PRIORITY);
#if AO_ADC_0
- ao_enable_analog(0, 11);
+ ao_enable_analog(0, 11, 0);
#endif
#if AO_ADC_1
- ao_enable_analog(0, 12);
+ ao_enable_analog(0, 12, 1);
#endif
#if AO_ADC_2
- ao_enable_analog(0, 13);
+ ao_enable_analog(0, 13, 2);
#endif
#if AO_ADC_3
- ao_enable_analog(0, 14);
+ ao_enable_analog(0, 14, 3);
#endif
#if AO_ADC_4
- ao_enable_analog(0, 14);
+ ao_enable_analog(0, 15, 4);
#endif
#if AO_ADC_5
- ao_enable_analog(0, 14);
+ ao_enable_analog(0, 16, 5);
#endif
#if AO_ADC_6
- ao_enable_analog(0, 14);
+ ao_enable_analog(0, 22, 6);
#endif
#if AO_ADC_7
- ao_enable_analog(0, 14);
+ ao_enable_analog(0, 23, 7);
#endif
+
+ lpc_adc.cr = ((AO_ADC_MASK << LPC_ADC_CR_SEL) |
+ (AO_ADC_CLKDIV << LPC_ADC_CR_CLKDIV) |
+ (0 << LPC_ADC_CR_BURST) |
+ (LPC_ADC_CR_CLKS_11 << LPC_ADC_CR_CLKS));
+
ao_cmd_register(&ao_adc_cmds[0]);
ao_adc_ready = 1;
#define AO_SPI_SPEED_FAST AO_SPI_SPEED_12MHz
+#define AO_BOOT_APPLICATION_BASE ((uint32_t *) 0x00001000)
+#define AO_BOOT_LOADER_BASE ((uint32_t *) 0x00000000)
+#define HAS_BOOT_LOADER 1
+
#endif /* _AO_ARCH_H_ */
#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
#define ao_enable_port(port) (lpc_scb.sysahbclkctrl |= (1 << LPC_SCB_SYSAHBCLKCTRL_GPIO))
+#define ao_disable_port(port) (lpc_scb.sysahbclkctrl &= ~(1 << LPC_SCB_SYSAHBCLKCTRL_GPIO))
#define lpc_all_bit(port,bit) (((port) << 5) | (bit))
#define ao_gpio_set(port, bit, pin, v) (lpc_gpio.byte[lpc_all_bit(port,bit)] = (v))
-#define ao_gpio_get(port, bit, pin) (lpc_gpio_byte[lpc_all_bit(port,bit)])
+#define ao_gpio_get(port, bit, pin) (lpc_gpio.byte[lpc_all_bit(port,bit)])
#define ao_enable_output(port,bit,pin,v) do { \
ao_enable_port(port); \
lpc_gpio.dir[port] |= (1 << bit); \
} while (0)
-#define ao_enable_input(port,bit,mode) do { \
+#define ao_gpio_set_mode(port,bit,mode) do { \
vuint32_t *_ioconf = &lpc_ioconf.pio0_0 + ((port)*24+(bit)); \
vuint32_t _mode; \
- ao_enable_port(port); \
- lpc_gpio.dir[port] &= ~(1 << bit); \
if (mode == AO_EXTI_MODE_PULL_UP) \
_mode = LPC_IOCONF_MODE_PULL_UP << LPC_IOCONF_MODE; \
else if (mode == AO_EXTI_MODE_PULL_DOWN) \
(1 << LPC_IOCONF_ADMODE)); \
} while (0)
-#define ao_enable_analog(port,bit) do { \
- vuint32_t *_ioconf = &lpc_ioconf.pio0_0 + ((port)*24+(bit)); \
+#define ao_enable_input(port,bit,mode) do { \
ao_enable_port(port); \
lpc_gpio.dir[port] &= ~(1 << bit); \
- *_ioconf = *_ioconf & ~((1 << LPC_IOCONF_ADMODE) | \
- (LPC_IOCONF_MODE_MASK << LPC_IOCONF_MODE)); \
+ ao_gpio_set_mode(port,bit,mode); \
+ } while (0)
+
+#define lpc_token_paster_2(x,y) x ## y
+#define lpc_token_evaluator_2(x,y) lpc_token_paster_2(x,y)
+#define lpc_token_paster_3(x,y,z) x ## y ## z
+#define lpc_token_evaluator_3(x,y,z) lpc_token_paster_3(x,y,z)
+#define lpc_token_paster_4(w,x,y,z) w ## x ## y ## z
+#define lpc_token_evaluator_4(w,x,y,z) lpc_token_paster_4(w,x,y,z)
+#define analog_reg(port,bit) lpc_token_evaluator_4(pio,port,_,bit)
+#define analog_func(id) lpc_token_evaluator_2(LPC_IOCONF_FUNC_AD,id)
+
+#define ao_enable_analog(port,bit,id) do { \
+ ao_enable_port(port); \
+ lpc_gpio.dir[port] &= ~(1 << bit); \
+ lpc_ioconf.analog_reg(port,bit) = ((analog_func(id) << LPC_IOCONF_FUNC) | \
+ (0 << LPC_IOCONF_ADMODE)); \
} while (0)
#define ARM_PUSH32(stack, val) (*(--(stack)) = (val))
asm volatile("" ::: "memory");
}
+#if HAS_TASK
static inline void
ao_arch_init_stack(struct ao_task *task, void *start)
{
#define ao_arch_isr_stack()
+#endif /* HAS_TASK */
+
#define ao_arch_wait_interrupt() do { \
asm(".global ao_idle_loc\n\twfi\nao_idle_loc:"); \
ao_arch_release_interrupts(); \
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_BOOT_H_
+#define _AO_BOOT_H_
+
+void
+ao_boot_chain(uint32_t *base);
+
+void
+ao_boot_check_pin(void);
+
+/* Return true to switch to application (if present) */
+int
+ao_boot_check_chain(void);
+
+void
+ao_boot_reboot(uint32_t *base);
+
+static inline void
+ao_boot_loader(void) {
+ ao_boot_reboot(AO_BOOT_LOADER_BASE);
+}
+
+#endif /* _AO_BOOT_H_ */
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_boot.h>
+
+void
+ao_boot_chain(uint32_t *base)
+{
+ uint32_t sp;
+ uint32_t pc;
+
+ sp = base[0];
+ pc = base[1];
+ if (0x00000100 <= pc && pc <= 0x00008000 && (pc & 1) == 1) {
+ asm ("mov sp, %0" : : "r" (sp));
+ asm ("mov lr, %0" : : "r" (pc));
+ asm ("bx lr");
+ }
+}
+
+#define AO_BOOT_SIGNAL 0x5a5aa5a5
+#define AO_BOOT_CHECK 0xc3c33c3c
+
+struct ao_boot {
+ uint32_t *base;
+ uint32_t signal;
+ uint32_t check;
+};
+
+static struct ao_boot __attribute__ ((section(".boot"))) ao_boot;
+
+int
+ao_boot_check_chain(void)
+{
+ if (ao_boot.signal == AO_BOOT_SIGNAL && ao_boot.check == AO_BOOT_CHECK) {
+ ao_boot.signal = 0;
+ ao_boot.check = 0;
+ if (ao_boot.base == 0)
+ return 0;
+ ao_boot_chain(ao_boot.base);
+ }
+ return 1;
+}
+
+void
+ao_boot_reboot(uint32_t *base)
+{
+ ao_boot.base = base;
+ ao_boot.signal = AO_BOOT_SIGNAL;
+ ao_boot.check = AO_BOOT_CHECK;
+ ao_arch_reboot();
+}
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <ao.h>
+#include <ao_boot.h>
+#include <ao_exti.h>
+
+void
+ao_boot_check_pin(void)
+{
+ uint16_t v;
+
+ /* Enable power interface clock */
+// stm_rcc.apb1enr |= (1 << STM_RCC_APB1ENR_PWREN);
+
+ /* Enable the input pin */
+ ao_enable_input(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN,
+ AO_BOOT_APPLICATION_MODE);
+
+ for (v = 0; v < 100; v++)
+ ao_arch_nop();
+
+ /* Read the value */
+ v = ao_gpio_get(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN, AO_BOOT_APPLICATION);
+
+ /* Reset the chip to turn off the port and the power interface clock */
+ ao_gpio_set_mode(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN, 0);
+ ao_disable_port(AO_BOOT_APPLICATION_GPIO);
+// stm_rcc.apb1enr &= ~(1 << STM_RCC_APB1ENR_PWREN);
+ if (v == AO_BOOT_APPLICATION_VALUE)
+ ao_boot_chain(AO_BOOT_APPLICATION_BASE);
+}
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_FLASH_H_
+#define _AO_FLASH_H_
+
+uint32_t
+ao_flash_erase_page(uint8_t *page);
+
+uint32_t
+ao_flash_page(uint8_t *page, uint8_t *src);
+
+uint32_t
+ao_lpc_read_part_id(void);
+
+#endif /* _AO_FLASH_H_ */
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include "ao.h"
+#include <ao_exti.h>
+#include <ao_boot.h>
+#include <ao_flash_task.h>
+
+int
+main(void)
+{
+ ao_clock_init();
+
+ ao_usb_init();
+
+ ao_flash_task();
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#ifndef _AO_FLASH_LPC_PINS_H_
+#define _AO_FLASH_LPC_PINS_H_
+
+#include <ao_flash_pins.h>
+
+/* Crystal on the board */
+#define AO_LPC_CLKIN 12000000
+
+/* Main clock frequency. 48MHz for USB so we don't use the USB PLL */
+#define AO_LPC_CLKOUT 48000000
+
+/* System clock frequency */
+#define AO_LPC_SYSCLK 24000000
+
+#endif /* _AO_FLASH_STM_PINS_H_ */
#include <ao.h>
#include <string.h>
+#include <ao_boot.h>
+
+#ifndef IS_FLASH_LOADER
+#error Should define IS_FLASH_LOADER
+#define IS_FLASH_LOADER 0
+#endif
+
+#if !IS_FLASH_LOADER
+#define RELOCATE_INTERRUPT 1
+#endif
extern void main(void);
extern char __stack__;
extern char __text_start__, __text_end__;
extern char __data_start__, __data_end__;
extern char __bss_start__, __bss_end__;
+#if RELOCATE_INTERRUPT
+extern char __interrupt_rom__, __interrupt_start__, __interrupt_end__;
+#endif
/* Interrupt functions */
{
}
-int x;
-
void start(void) {
- x = 0;
+#ifdef AO_BOOT_CHAIN
+ if (ao_boot_check_chain()) {
+#ifdef AO_BOOT_PIN
+ ao_boot_check_pin();
+#endif
+ }
+#endif
+#if RELOCATE_INTERRUPT
+ memcpy(&__interrupt_start__, &__interrupt_rom__, &__interrupt_end__ - &__interrupt_start__);
+ lpc_scb.sysmemremap = LPC_SCB_SYSMEMREMAP_MAP_RAM << LPC_SCB_SYSMEMREMAP_MAP;
+#endif
memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
main();
/* recv a byte */ \
get lpc_ssp->dr; \
} \
- } while (0);
+ } while (0)
void
ao_spi_send(void *block, uint16_t len, uint8_t id)
(1 << LPC_SCB_SYSAHBCLKCTRL_GPIO) |
(1 << LPC_SCB_SYSAHBCLKCTRL_IOCON));
+ /* Enable the brown-out detection at the highest voltage to
+ * make sure the flash part remains happy
+ */
+
+ lpc_scb.pdruncfg &= ~(1 << LPC_SCB_PDRUNCFG_BOD_PD);
+ lpc_scb.bodctrl = ((LPC_SCB_BOD_BODRSTLEV_2_63 << LPC_SCB_BOD_BODRSTLEV) |
+ (LPC_SCB_BOD_BODINTVAL_RESERVED << LPC_SCB_BOD_BODINTVAL) |
+ (1 << LPC_SCB_BOD_BODRSTENA));
+
/* Turn the IRC clock back on */
lpc_scb.pdruncfg &= ~(1 << LPC_SCB_PDRUNCFG_IRC_PD);
ao_clock_delay();
/* Switch to the IRC clock */
lpc_scb.mainclksel = LPC_SCB_MAINCLKSEL_SEL_IRC << LPC_SCB_MAINCLKSEL_SEL;
- lpc_scb.mainclkuen = (1 << LPC_SCB_MAINCLKUEN_ENA);
lpc_scb.mainclkuen = (0 << LPC_SCB_MAINCLKUEN_ENA);
lpc_scb.mainclkuen = (1 << LPC_SCB_MAINCLKUEN_ENA);
while (!(lpc_scb.mainclkuen & (1 << LPC_SCB_MAINCLKUEN_ENA)))
;
+ /* Switch USB to the main clock */
+ lpc_scb.usbclksel = (LPC_SCB_USBCLKSEL_SEL_MAIN_CLOCK << LPC_SCB_USBCLKSEL_SEL);
+ lpc_scb.usbclkuen = (0 << LPC_SCB_USBCLKUEN_ENA);
+ lpc_scb.usbclkuen = (1 << LPC_SCB_USBCLKUEN_ENA);
+ while (!(lpc_scb.usbclkuen & (1 << LPC_SCB_USBCLKUEN_ENA)))
+ ;
+
/* Find a PLL post divider ratio that gets the FCCO in range */
for (p = 0; p < 4; p++)
if (AO_LPC_CLKOUT << (1 + p) >= AO_LPC_FCCO_MIN)
lpc_scb.ssp1clkdiv = 0;
lpc_scb.usbclkdiv = 0;
lpc_scb.clkoutdiv = 0;
+
+ /* Switch USB PLL source to system osc so we can power down the IRC */
+ lpc_scb.usbpllclksel = (LPC_SCB_USBPLLCLKSEL_SEL_SYSOSC << LPC_SCB_USBPLLCLKSEL_SEL);
+ lpc_scb.usbpllclkuen = (0 << LPC_SCB_USBPLLCLKUEN_ENA);
+ lpc_scb.usbpllclkuen = (1 << LPC_SCB_USBPLLCLKUEN_ENA);
+ while (!(lpc_scb.usbpllclkuen & (1 << LPC_SCB_USBPLLCLKUEN_ENA)))
+ ;
+
+ /* Power down everything we don't need */
+ lpc_scb.pdruncfg = ((1 << LPC_SCB_PDRUNCFG_IRCOUT_PD) |
+ (1 << LPC_SCB_PDRUNCFG_IRC_PD) |
+ (0 << LPC_SCB_PDRUNCFG_BOD_PD) |
+ (1 << LPC_SCB_PDRUNCFG_ADC_PD) |
+ (1 << LPC_SCB_PDRUNCFG_WDTOSC_PD) |
+ (1 << LPC_SCB_PDRUNCFG_USBPLL_PD) |
+ (1 << LPC_SCB_PDRUNCFG_USBPAD_PD) |
+ (1 << 11) |
+ (7 << 13));
}
#include "ao_usb.h"
#include "ao_product.h"
+#ifndef USE_USB_STDIO
+#define USE_USB_STDIO 1
+#endif
+
+#if USE_USB_STDIO
+#define AO_USB_OUT_SLEEP_ADDR (&ao_stdin_ready)
+#else
+#define AO_USB_OUT_SLEEP_ADDR (&ao_usb_out_avail)
+#endif
+
#define USB_DEBUG 0
#define USB_DEBUG_DATA 0
#define USB_ECHO 0
#define debug_data(format, args...)
#endif
-struct ao_task ao_usb_task;
-
struct ao_usb_setup {
uint8_t dir_type_recip;
uint8_t request;
_rx_dbg1("RX ISR", *ao_usb_epn_out(AO_USB_OUT_EP));
ao_usb_out_avail = 1;
_rx_dbg0("out avail set");
- ao_wakeup(&ao_stdin_ready);
+ ao_wakeup(AO_USB_OUT_SLEEP_ADDR)
_rx_dbg0("stdin awoken");
}
ao_arch_block_interrupts();
while ((c = _ao_usb_pollchar()) == AO_READ_AGAIN)
- ao_sleep(&ao_stdin_ready);
+ ao_sleep(AO_USB_OUT_SLEEP_ADDR);
ao_arch_release_interrupts();
return c;
}
{
ao_arch_block_interrupts();
+#if HAS_USB_PULLUP
+ ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+#endif
/* Disable interrupts */
lpc_usb.inten = 0;
/* Turn off USB clock */
lpc_scb.usbclkdiv = 0;
- /* Disable USB PHY */
- lpc_scb.pdruncfg |= (1 << LPC_SCB_PDRUNCFG_USBPAD_PD);
+ /* Disable USB PHY and PLL */
+ lpc_scb.pdruncfg |= ((1 << LPC_SCB_PDRUNCFG_USBPAD_PD) |
+ (1 << LPC_SCB_PDRUNCFG_USBPLL_PD));
/* Disable USB registers and RAM */
lpc_scb.sysahbclkctrl &= ~((1 << LPC_SCB_SYSAHBCLKCTRL_USB) |
lpc_scb.pdruncfg &= ~(1 << LPC_SCB_PDRUNCFG_USBPLL_PD);
lpc_scb.usbpllclksel = (LPC_SCB_SYSPLLCLKSEL_SEL_SYSOSC << LPC_SCB_SYSPLLCLKSEL_SEL);
- lpc_scb.usbpllclkuen = (1 << LPC_SCB_USBPLLCLKUEN_ENA);
lpc_scb.usbpllclkuen = (0 << LPC_SCB_USBPLLCLKUEN_ENA);
lpc_scb.usbpllclkuen = (1 << LPC_SCB_USBPLLCLKUEN_ENA);
while (!(lpc_scb.usbpllclkuen & (1 << LPC_SCB_USBPLLCLKUEN_ENA)))
;
lpc_scb.usbclksel = 0;
+ lpc_scb.usbclkuen = (0 << LPC_SCB_USBCLKUEN_ENA);
+ lpc_scb.usbclkuen = (1 << LPC_SCB_USBCLKUEN_ENA);
+ while (!(lpc_scb.usbclkuen & (1 << LPC_SCB_USBCLKUEN_ENA)))
+ ;
/* Turn on USB clock, use 48MHz clock unchanged */
lpc_scb.usbclkdiv = 1;
for (t = 0; t < 1000; t++)
ao_arch_nop();
+#if HAS_USB_PULLUP
+ ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 1);
+#endif
+
ao_usb_set_ep0();
}
void
ao_usb_init(void)
{
+#if HAS_USB_PULLUP
+ ao_enable_output(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+#endif
+
ao_usb_enable();
debug ("ao_usb_init\n");
#if USB_DEBUG
ao_cmd_register(&ao_usb_cmds[0]);
#endif
-#if !USB_ECHO
+#if USE_USB_STDIO
ao_add_stdio(_ao_usb_pollchar, ao_usb_putchar, ao_usb_flush);
#endif
}
extern struct lpc_scb lpc_scb;
+#define LPC_SCB_SYSMEMREMAP_MAP 0
+# define LPC_SCB_SYSMEMREMAP_MAP_BOOT_LOADER 0
+# define LPC_SCB_SYSMEMREMAP_MAP_RAM 1
+# define LPC_SCB_SYSMEMREMAP_MAP_FLASH 2
+
#define LPC_SCB_PRESETCTRL_SSP0_RST_N 0
#define LPC_SCB_PRESETCTRL_I2C_RST_N 1
#define LPC_SCB_PRESETCTRL_SSP1_RST_N 2
#define LPC_SCB_CLKOUTUEN_ENA 0
+#define LPC_SCB_BOD_BODRSTLEV 0
+# define LPC_SCB_BOD_BODRSTLEV_1_46 0
+# define LPC_SCB_BOD_BODRSTLEV_2_06 1
+# define LPC_SCB_BOD_BODRSTLEV_2_35 2
+# define LPC_SCB_BOD_BODRSTLEV_2_63 3
+#define LPC_SCB_BOD_BODINTVAL 2
+# define LPC_SCB_BOD_BODINTVAL_RESERVED 0
+# define LPC_SCB_BOD_BODINTVAL_2_22 1
+# define LPC_SCB_BOD_BODINTVAL_2_52 2
+# define LPC_SCB_BOD_BODINTVAL_2_80 3
+#define LPC_SCB_BOD_BODRSTENA 4
+
#define LPC_SCB_PDRUNCFG_IRCOUT_PD 0
#define LPC_SCB_PDRUNCFG_IRC_PD 1
#define LPC_SCB_PDRUNCFG_FLASH_PD 2
static inline void
lpc_nvic_set_enable(int irq) {
- lpc_nvic.iser |= (1 << irq);
+ lpc_nvic.iser = (1 << irq);
}
static inline void
lpc_nvic_clear_enable(int irq) {
- lpc_nvic.icer |= (1 << irq);
+ lpc_nvic.icer = (1 << irq);
}
static inline int
#define LPC_ADC_CR_CLKS_6 5
#define LPC_ADC_CR_CLKS_5 6
#define LPC_ADC_CR_CLKS_4 7
+#define LPC_ADC_CR_START 24
+#define LPC_ADC_CR_START_NONE 0
+#define LPC_ADC_CR_START_NOW 1
+
+#define LPC_ADC_GDR_CHN 24
+#define LPC_ADC_GDR_OVERRUN 30
+#define LPC_ADC_GDR_DONE 31
#define LPC_ADC_INTEN_ADINTEN 0
#define LPC_ADC_INTEN_ADGINTEN 8
#define AO_BOOT_CHAIN 1
#define AO_BOOT_PIN 1
+#define IS_FLASH_LOADER 1
+
#endif /* _AO_FLASH_PINS_H_ */
ao_block_erase(void)
{
uint32_t addr = ao_get_hex32();
- uint32_t *p = (uint32_t *) addr;
+ void *p = (void *) addr;
ao_flash_erase_page(p);
}
ao_block_write(void)
{
uint32_t addr = ao_get_hex32();
- uint32_t *p = (uint32_t *) addr;
- union {
- uint8_t data8[256];
- uint32_t data32[64];
- } u;
+ void *p = (void *) addr;
+ uint8_t data[256];
uint16_t i;
if (addr < (uint32_t) AO_BOOT_APPLICATION_BASE) {
return;
}
for (i = 0; i < 256; i++)
- u.data8[i] = ao_usb_getchar();
- ao_flash_page(p, u.data32);
+ data[i] = ao_usb_getchar();
+ ao_flash_page(p, (void *) data);
}
static void
#define AO_LED_CONTINUITY(c) (1 << ((c) + 2))
#define AO_LED_CONTINUITY_MASK (0xc)
-#define AO_LED_RX 0x10
-#define AO_LED_TX 0x20
-#define AO_LED_ARMED 0x40
-#define AO_LED_POWER 0x80
-
-#define AO_LED_RED AO_LED_TX
-#define AO_LED_GREEN AO_LED_RX
+#define AO_LED_ARMED 0x10
+#define AO_LED_RED 0x20
+#define AO_LED_AMBER 0x40
+#define AO_LED_GREEN 0x80
#define LEDS_AVAILABLE (0xff)
#define HAS_EXTERNAL_TEMP 0
#define AO_LED_CONTINUITY(c) (1 << (c))
#define AO_LED_CONTINUITY_MASK (0xf)
-#define AO_LED_RX 0x10
-#define AO_LED_TX 0x20
-#define AO_LED_ARMED 0x40
-#define AO_LED_POWER 0x80
-
-#define AO_LED_RED AO_LED_TX
-#define AO_LED_GREEN AO_LED_RX
+#define AO_LED_ARMED 0x10
+#define AO_LED_RED 0x20
+#define AO_LED_AMBER 0x40
+#define AO_LED_GREEN 0x80
#define LEDS_AVAILABLE (0xff)
#define HAS_EXTERNAL_TEMP 0
cc $(CFLAGS) -o $@ ao_micropeak_test.c -lm
ao_fat_test: ao_fat_test.c ao_fat.c ao_bufio.c
- cc $(CFLAGS) -o $@ ao_fat_test.c -lssl
+ cc $(CFLAGS) -o $@ ao_fat_test.c -lssl -lcrypto
ao_aes_test: ao_aes_test.c ao_aes.c ao_aes_tables.c
cc $(CFLAGS) -o $@ ao_aes_test.c